Lab 4: Edge Detection in Images

A. Background Information

Edge detection is a common, but very important method for analyzing images. It can be used to help identify objects in a scene or features of an object. It is widely used in biometrics security applications to identify facial features or fingerprints. The example below shows the process of edge detection applied to a picture of a bike next to a brick wall. As can be seen, edge detection easily shows the outline of the bike, the bricks in the wall, and even the writing on the bike.

| | Edge Detection Example: Original Image (left) and Edge Detected Image (right) | So how does edge detection work? The first step in understanding the process is to understand what an edge is in an image. If you were to look at the values of in an image along a single row or column, you would see something that looks like this:
Bricks
Bricks
Grout Lines
Grout Lines

This is actually the graph of the pixel values from the first row of the original picture shown above. What you are seeing here are the individual dark colored bricks that make up the top border of the image. The bricks themselves are the lower and relatively flat sections, while the lighter colored grout between the bricks is represented by the sharp peaks. With this understanding, we can see that an edge (a sharp change in color) is represented by a large change in the pixel value.

In order to locate the areas that have these drastic changes in color, we need to apply a mathematical operation to the image. In this case, since we want to know the change in the color values, we will be using a derivative, since a derivative is large when there is a drastic change (an edge) and small when there is little change (not an edge).

So far, we’ve only been applying derivatives to 1-dimensional data using the 2 point and 3 point derivative estimates. So how do we apply a derivative to a 2-dimensional image? The process is essentially the same. However, in this case, we will be applying the 3 point derivative estimate to three rows (or columns) and adding the results together to determine whether there is an edge at the location in the image. The next section describes the process by which we will apply the derivative to an image.

B. Understand the Process

The process we will use to perform edge detection is what is called 2-D filtering, but in essence, we will be applying the 3 point derivative estimate over a 3x3 section of our image to check and see if there is an edge present. The filter that we will be using is called a Prewitt Filter, and looks like this:

Prewittx=-101-101-101 Prewitty=-1-1-1000111

The filter is applied as follows: 1) Access a 3x3 portion of the image 2) Multiply each value in the filter by the corresponding value from the image 3) Add up the results of the multiplications and take the absolute value (this is done because all image values are positive, but we want to find any large change, be it from low to high or high to low pixel values) 4) Store the resulting value into a new image at the location of the center of the portion from the original image

Assume we have the image portion shown below, which was taken from rows 4-6 and columns 3-5 of the full image. If we were to look at what is happening mathematically when applying the Prewittx filter, we would calculate a value for NewImage(5,4) as follows:

image4:6,3:5=507515052741545176149

P=507515052741545176149.*-101-101-101 = -500150-520154-510149

NewImage5,4=|Sum of Values in P|=150-50+154-52+149-51
This is the same thing as the sum of three 3 point derivative estimates (with 2Δt = 1). To apply this filter to the whole image, we simply pull out a different part of the image and apply the filter, storing the result into the new image. The one thing to note is that the filter cannot be applied to border of the image, since you cannot pull out a 3x3 matrix centered along the border. Typically, the border of an edge-detected image is simply left black (value = 0).
Assume that we have an image as shown below. Complete the table by applying the edge detection algorithm described above, using the Prewittx filter and the Prewitty filter.

Original Image: 0 | 0 | 255 | 0 | 0 | 0 | 0 | 255 | 0 | 0 | 0 | 0 | 255 | 0 | 0 | 0 | 0 | 255 | 0 | 0 | 0 | 0 | 255 | 0 | 0 |

Prewittx: 0 | 0 | 0 | 0 | 0 | 0 | 765 | 0 | 765 | 0 | 0 | 765 | 0 | 765 | 0 | 0 | 765 | 0 | 765 | 0 | 0 | 0 | 0 | 0 | 0 |

Prewitty: 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |

What do you notice about the values when you use the Prewittx and Prewitty filters? What effect do you think this will have when you apply this to an actual image? The Prewittx filters the image to be black apart from some parts where it is at a different value whereas Prewitty turns everything black |

C. Implementation of Edge Detection

Write a script that implements edge detection using the Prewittx filter. Your script should follow the procedure outlined below:

1. Load an image into MATLAB using the imread command. 2. Check to see whether the image is a color image or a grayscale image by checking the number of planes along the third dimension (i.e. 1 plane is grayscale, 3 planes is color). 3. If the image is a color image, convert it to grayscale using the conversion shown below where X is the original color image and Pic is the resulting grayscale image.

Pic = 0.299*X(:,:,1) + 0.587*X(:,:,2) + 0.114*X(:,:,3);

4. Display the grayscale image using the imshow command. 5. Convert Pic to a double. 6. Create a new array filled with zeros that is the same size as your image. 7. Apply the Prewittx filter to the image as follows: a. Pull out a section of the original image. b. Multiply each value in the section of the image by the corresponding values in the filter. c. Add all of the values together. d. Take the absolute value of the final value. e. Store the final value into your new image array at the center of the section you just filtered. f. Repeat for all possible sections of the original image (remember, you cannot do this for the border values!). 8. Scale the new image so that the minimum value is 0 and the maximum value is 255. 9. Display your edge-detected image using the imshow command. You will first need to convert the image back into uint8 format using the uint8 command.

Once you have your script written and working, select one of the two provided images. The Arm_Fracture.jpg image is an x-ray image of a broken arm. As you can see, this person has a transverse fracture of the radius. It is fairly easy to identify where the fracture is, but it would be very difficult for a computer to identify this fracture in an automated way. Applying edge detection will help to show the outline of the bones and make it easier for a computer to automatically locate the fracture, making the job easier for the physician.

The Schockwave.jpg image shows the pattern produced by an object moving at a high rate of speed through a medium. As you can see from the image, there is quite a complicated pattern produced as the object moves, but there is also some noise in the picture (horizontal repeating lines) that might make it difficult to analyze. Again, by applying edge detection, we can emphasize the pattern produced by the object as it travels through the medium and remove some of the unwanted noise.

Run your script using your selected image and paste a copy of your results below:

Paste your script file here:

clear all; clc; Z = imread('Arm_Fracture.jpg');
Pic = 0.299*Z(:,:,1) + 0.587*Z(:,:,2) + 0.114*Z(:,:,3); figure(1); imshow(Pic);
NewPic = double(Pic);
PicSize = size(NewPic);
NewImageX = zeros(PicSize);
NewImageY = zeros(PicSize);
X = [-1 0 1; -1 0 1; -1 0 1];
Y = [-1 -1 -1; 0 0 0; 1 1 1]; for row = 1:PicSize(1)-2 for col = 1:PicSize(2)-2 Px = NewPic(row:row+2,col:col+2).*X; Py = NewPic(row:row+2,col:col+2).*Y; NewImageX(row,col) = abs(sum(sum(Px))); NewImageY(row,col) = abs(sum(sum(Py))); end end NewImageX = (255)/max(max(NewImageX))*NewImageX;
NewImageY = (255)/max(max(NewImageY))*NewImageY;
NewImageX = uint8(NewImageX);
NewImageY = uint8(NewImageY); figure(2); imshow(NewImageX); figure(3); imshow(NewImageY);

Looking at the image you produced, which types of edges were you able to find? White Edges |

What do you think you should do in order to find other edges in your image? Use different filters |

D. Improved Edge Detection

Modify your script file so that it applies three more filters to the image and adds the results together as follows:

1. Add code to create three additional arrays filled with zeros that are the same size as your original image. 2. Add code to apply the Prewitty filter shown previously and two diagonal Prewitt filters, shown below:
Prewittd1=-1-10-101011 Prewittd2=011-101-1-10 3. Add code to scale the three new images so that the minimum value in each image is 0 and the maximum value is 255. 4. Add code to display your new edge-detected images using the imshow command. You can either display all four images in separate figures or use subplot to display them all in one window. Don’t forget to convert to uint8 first. 5. Add code to add each of the four edge-detected images together. 6. Add code to scale the summed image so that it again within the range of 0 to 255. 7. Add code to display the summed image using the imshow command.

Run your new script using your selected image and paste a copy of your results for the four individual and the final summed edge-detected images below:

Paste your improved script file here:

clear all; clc; Z = imread('Arm_Fracture.jpg');
Pic = 0.299*Z(:,:,1) + 0.587*Z(:,:,2) + 0.114*Z(:,:,3); figure(1); imshow(Pic);
NewPic = double(Pic);
PicSize = size(NewPic);
NewImageX = zeros(PicSize);
NewImageY = zeros(PicSize);
NewImageD1 = zeros(PicSize);
NewImageD2 = zeros(PicSize);
X = [-1 0 1; -1 0 1; -1 0 1];
Y = [-1 -1 -1; 0 0 0; 1 1 1];
D1 = [-1 -1 0; -1 0 1; 0 1 1];
D2 = [0 1 1; -1 0 1; -1 -1 0]; for row = 1:PicSize(1)-2 for col = 1:PicSize(2)-2 Px = NewPic(row:row+2,col:col+2).*X; Py = NewPic(row:row+2,col:col+2).*Y; PD1 = NewPic(row:row+2,col:col+2).*D1; PD2 = NewPic(row:row+2,col:col+2).*D2; NewImageX(row,col) = abs(sum(sum(Px))); NewImageY(row,col) = abs(sum(sum(Py))); NewImageD1(row,col) = abs(sum(sum(PD1))); NewImageD2(row,col) = abs(sum(sum(PD2))); end end NewImageX = (255)/max(max(NewImageX))*NewImageX;
NewImageY = (255)/max(max(NewImageY))*NewImageY;
NewImageD1 = (255)/max(max(NewImageD1))*NewImageD1;
NewImageD2 = (255)/max(max(NewImageD2))*NewImageD2;
NewImageX = uint8(NewImageX);
NewImageY = uint8(NewImageY);
NewImageD1 = uint8(NewImageD1);
NewImageD2 = uint8(NewImageD2); figure(2); subplot(2,2,1); imshow(NewImageX); subplot(2,2,2); imshow(NewImageY); subplot(2,2,3); imshow(NewImageD1); subplot(2,2,4); imshow(NewImageD2);

Looking at the results of the four individual Prewitt filters, what do you notice about the types of edges found? What is it about these filters that allow them to find these types of edges? The types of edges found are more like the surroundings or the borders of the element in the picture |

How does the summed image compare to the individual images?

|

If you chose the Arm_Fracture.jpg image and you are designing a computer system to identify the fracture automatically, what procedure might you use now that you have the edge-detected image?

OR

If you chose the Shockwave.jpg image, now that you have the edge-detected image, what features might you want to investigate if you are trying to analyze the pattern produced?

|

E. For Fun!

As was mentioned in the introduction, one of the applications for edge detection is to identify facial features for the purposes of biometric security and facial recognition. Take a selfie and run the image through your edge detection code.

Paste a copy of your original (grayscale) and edge-detected selfie below:

F. To be turned in: * You will need to upload this word document with all requested tables, questions, and figures included and the m-file for your final script.