So now let's take our Gaussian and
convolve it with the image. So now
remember that A is 512 x 512 x 3,
which is a three-dimensional matrix, and
H is a two-dimensional matrix. So if I
try to do this I'm going to get an error
I'm sorry we are using the CONV2
function, and you still get an error
because A is not supposed to be a
three-dimensional matrix, right. So if we
look at the definition of convolution
we're working with two dimensional
matrices, if we have two dimensional
convolution. So what we want to do is
let's just take the red channel and it
doesn't matter which one, because
remember when we were looking at the red,
green, and blue channels we pretty much
saw the same image for every channel.
Ok, so, we still get another warning and
that's that A is still in values of
UINT8, so let's change that to double.
Ok, so, now let's imshow(C) and see what we get.
So it's all white, and so what does white
mean? That means all of the values are too
high, right, so there's too much intensity
in this image. So, you have to play around
with the values a little bit, so let's
try making a smaller filter.
Ok, so, let's say H is equal to my_gaussian
25 and then sigma is 5. So now
the filter's smaller and the sigma is
smaller, so the blur is going to be less,
but the intensity is still too high. So
that could mean just the values are too
high and we need to multiply by lower
values. So let's divide the filter values
H x 1000, and imshow(C) again. So now we're
starting to see some black, right, so
that's good.
Ok, so, I'm decreasing values and I'm
starting to see the image.
Okay, so, here's the original image but
blurred using a Gaussian of sigma equals
5.
Now one thing I didn't show you guys
because I wanted you to go through the
exercise of creating a two dimensional
Gaussian filter yourself, is that we
already have a function called fspecial
in matlab that create filters for us, and
so fspecial can create many different
types of filters. So, in addition to the
Gaussian it can create laplacian filters,
an averaging filter which is another
thing we've used, the Sobell filter which
is useful for finding edges, so all
different types of filters. So let's try
using fspecial instead.
fspecial('gaussian', 25, 5);
Now let's do our convolution. So I'm going to divide
by a thousand, because I know I'm going to have
to divide. So let's just see what we see.
Ok, and so it's a little dark so I didn't
have to divide by a thousand, maybe
I could had divided a lower number, but you can see
the idea is that we've blurred the
original image using the gaussian filter
given to us by fspecial instead of our
own Gaussian filter that we built.
Ok, so, like we did before I want to plot
the filter that we created. So I'm going
to go imshow little h, which is the
filter we created with fspecial, and
notice how it's just all black. Remember
that 0 is black and 1 is white. So what
we could do if we want to look at what's in
h,
let's check the maximum value of h. So
max, max because it's two-dimensional. The
maximum value is .0065,
so of course wwhen we plot that it's going to be
pretty close to black.
So what we could do if we want to scale
it by one, if we want the maximum value to
be one, we could do imshow(h) divided by
the maximum value.
Ok, so, now we see what we expect to see
which is white in the middle. So one
question you might have is why is the
value of h so small when we use
fspecial? That's because it does a
thing called normalization. So if you
have ever studied probability you know
that a probability distribution has to
sum to 1, so here it is a similar thing. So if
we sum across both dimensions of h we
get 1, and so
that's why the values of h are so small.
And so now just for completion sake, I
want to do sort of what's the opposite
of blurring, I want to do edge detection
of the image. So I want to find all the
edges and set those values to 1. So matlab
has a method called edge that will do
this, and it's very simple to use. You
pass in again the grayscale image,
right, so only a two-dimensional matrix
that won't work if you pass in the
entire image matrix.
Ok, so, edge just does all of that
automatically for you. So if imshow(E)
I can more or less see where all the
sharpest edges are, and of course there
are parameters you can pass into edge to
make it more or less sensitive, but this
is by default what it does.