This document provides details on course work completed as part of a Computer Vision course. It includes source images and summaries of edge detection algorithms applied to the images. Edge detection was performed using Roberts, Sobel, Prewitt and Robinson operators, as well as Laplacian of Gaussian. Thresholding techniques are discussed for binarizing the edge detection outputs. The effects of mask size and sigma values on Laplacian of Gaussian are demonstrated. Pseudocode is provided for the convolution operations.

1. 1
Jonathan Westlake
Software Engineer
Course Work Computer Vision
8/15/2015
The following is course work from my Computer Vision course during my Computer Science master’s
program. I have included it to demonstrate my understanding of 2D image processing. In practice many
of the techniques and data analysis are very similar to signal processing. An image is represented by data
values and I demonstrate various different ways I analysis the data to produce a desired result.
The following images and end results are 100% developed and tested by myself in C/C++. This is
everything except the initial starter code to read and write bitmaps. I can provide the source code if more
details on how a particular algorithm was implemented. However it was never intended as work to represent
the best practices of software development.
Thanks,
Jonathan

2. 2
CALIFORNIA STATE UNIVERSITY, LONG BEACH
College of Engineering
Department of Computer Engineering and Computer Science
Dr. Thinh V. Nguyen
Spring 2013
CECS-553/653: Machine Vision
PROJECT 1
Name: Westlake, Jonathan
Last, First
 Dates: Date assigned: Wednesday February 6, 2013. Date due: Wednesday March 27, 2013. Late
submissions will receive penalty at 10% per day. This project is worth 40% of the project grade.
 Objectives: The objectives of this project includes: (1) to familiarize students with the bitmap image file
format, (2) to perform edge detections.
 Project Description:
Write a computer program to read in an image named “image.bmp” where image is the input to the
program and is selected from the image database. If the image is color, save the image in grey level as
“image_grey.bmp”. Note that the word “image” should be replaced with the appropriate image file name.
Perform the following operations:
1) Edge detection using Roberts, Sobel, Prewitt, and Robinson operators: (40 points) Apply the Roberts,
Sobel, Prewitt, and Robinson operators on the image_grey.bmp. Show the resulting output. Then,
threshold the output images to obtain the edge images. The edge pixels are black and the non-edge pixels
are white. Discuss how you select the threshold to obtain the edge images.
2) Edge detection using Laplacian of Gaussian: (60 points) Apply the Laplacian of Gaussian with mask sizes
of 11x11 and 21x 21 on the above images. Show the values of the masks. For each mask size, select
various values of . Use zero crossings to detect the edges. Discuss the effects of mask size and on the
resulting edge images.
3) Results: Use the following images: actress.bmp, pattern2.bmp, coins.bmp. Use any additional images
and/or values of NxN as appropriate.
 Project Report: Follow the required format. Attach this sheet as cover sheets for the report. Attach
printouts of the above images as embedded pictures in the text. Scale the images to fit about 1/3 to ¼ of the
page. Discuss the results and specific implementations
END OF DOCUMENT

3. 3
Source Images:

4. 4
Part 1.) Edge detection using Roberts, Sobel, Prewitt and Robinson
This project uses Roberts, Sobel, Prewitt and Robinson operators by using convolution on the images to
detect edges. The Roberts operator is a 2x2, and the other three are 3x3 (Given in the pseudocode). In all
of the resulting images it is seen that images performed with Roberts have a duller edge values in
comparison to all the other operators when they are presented. When using thresholding we can see that
Roberts operator does not necessary loose pixel information regarding what is a line and what isn’t.
However it does introduce a great deal more noise than the other three. This is assumed to be based
around the small amount of calculations that go into producing one pixel. The Sobel operator gives the
greatest contrast from dark to white pixels. Many of these images appear to stand out due to the think
white lines that are present throughout the images. Prewitt and Robinson results appear to be very similar
with only a slight difference in pixel locations form comparing images.
Thresholding can be useful in image processing by selecting a value that is both greater and lower than
values within an image. In this project thresholding is used to give a strong contrast from black and white
pixels. This is very useful when an image contains too many dark pixels and there needs to be a way to
differentiate between them. A pixel that is greater than the threshold is changed to white (or value 0), and
a pixel lower than the threshold is changed black (255). This is only true in the context of this project
since the masks show highlighted lines in white and we wish to change these colors for printing to black.
I decided in this project to go with the average of all the pixels to find a given threshold value. This
appears to be a decent approach where images have a uniform contrast among pixels. This means that
there isn’t the need for an adaptive approach where areas may be too dark, or too light. The problem
however with selecting the average pixel thresholding is that too much extra noise goes into the
calculation. This can be seen in the actress.bmp thresholding example using averaging alone. In the
images there is the addition of noise on the face that may not be useful in image processing. Therefore in
this project I decided to double this value to help eliminate that noise and focus on the lines. This
depends highly on the “goals” of what one is trying to achieve. In this project the goal I’m assuming is
that we want clean lines in the photo to use. This may not be the best threshold value for coins.bmp.
This is because the level may remove too much of the lines that form the circles of the coin and may not
be useful in a computer vision processing application that will fail at the discontinuities.
Above is actress.bmp’s histogram after Sobel operator has been performed. As discussed the using the
average value as the threshold shows extra noise in the photos. In other photographs a histogram may
show many different peaks, and it would be more ideal to find the best area between those peaks to use as
a threshold value. This project only doubles the average to find its threshold value. The use of
calculating a standard deviation from the average could also be used.

5. 5
Pseudocode Example:
Define Masks:
RobertsSx[2][2] = { { 0 ,1 }, {-1, 0} }
RobertsSy[2][2] = { {1 ,0}, {0, -1}}
SobelSx[3][3] = { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1} }
SobelSy[3][3] = { { 1, 2, 1 }, { 0, 0, 0 }, { -1, -2, -1} }
PrewittSx[3][3] = { { -1, 0, 1 }, { -1, 0, 1 }, { -1, 0, 1} }
PrewittSy[3][3] = { { 1, 1, 1 }, { 0, 0, 0 }, { -1, -1, -1} }
RobinsonSx[3][3] = { { -1, 1, 1 }, { -1, -2, 1 }, { -1, 1, 1} }
RobinsonSy[3][3] = { { 1, 1, 1 }, { 1, -2, 1}, { -1, -1, -1} }
Define image – consists of a matrix that is loaded from one color of a 24-bit Bitmap Image. The
single color is used for 8-bit grey scale imaging.
For Every Mask Set {MaskNameRx, MaskNameRy}
MatrixRx = Convolution(MaskNameRx, image)
MatrixRy = Convolution(MaskNameRy, image)
For Every index in MatrixRx[0..x][0..y] and MatrixRy[0..x][0..y]
MatrixFinal[][]=√(MatrixRx[][]2
+ MatrixRy[][]2
)
Threshold = average(MatrixFinal)
For Every index in MatrixFinal[0..n]
if MatrixFinal[][] less than threshold
Set MatrixFinal[][] to BLACK
else
Set MatrixFinal[][] to WHITE
Write MatrixFinal to Output
Define method Convolution – Assume kernel has equal rows, columns to not require a flip in matrix.
inputs: MatrixKernel, MatrixImage : Dimensions(MatrixKernel) < Dimensions( MatrixImage )
For Every index in MatrixImage[0..x][0..y] thats boundaries are >
length(MatrixKernel[][]) – so offset doesn’t access elements out of bounds.
For Every index in MatrixKernel[0..x][0..y]
{IoffsetX,IoffsetY} = Offset of Kernel Window in relation to Image Matirx
MatrixOutput[0..x][0..y] = Summation(MatrixKernel[KoffsetX][KoffsetY] *
MatrixImage[IoffsetX][IoffsetY])
return MatrixOutput

6. 6
actress.bmp
Roberts Sobel Prewitt Robinson
Thresholding (Using Average of all pixels):
Roberts Sobel Prewitt Robinson
Roberts Sobel Prewitt Robinson
Thresholding (2 Times the Average)
Results show thick edge detection in areas where contrast between light and dark elements are vivid. This
is expected since areas like the shoulder should show a solid line, while marks around the face shouldn’t
show up at all. The Roberts operator with its smaller kernel size does not pull in a large enough window
of information and blocky looking pixels are apparent in its thresholded photos. A threshold value that is
that blocks many dark pixels will remove some elements in the photo that give texture and structure to the
image.

7. 7
pattern2.bmp
Roberts Sobel
Prewitt Robinson
Thresholding:
Roberts Sobel
Prewitt Robinson

8. 8
coins.bmp
Roberts Sobel
Prewitt Robinson
Thresholding:
Roberts Sobel
Prewitt Robinson

9. 9
Part 2.Edge detection using Laplacian of Gaussian)
When creating a mask with a given sigma value it expands values into the range based on the calculation
from the LoG(x,y) values entered into the function above. In the examples below a sigma value of (1.3 to
2.2) will best fit into an 11x11 mask. We could test higher values of sigma in the lower mask size, but
this will truncate important values that go outside of the 11x11 bounds. This is also true with using a
smaller value of sigma, where many of the elements within the mask will not be used since they are of
value 0. The larger 21x21 masks will best fit a sigma value of 2.5 and above. It is also noted that the
values within the mask get smaller, and a larger scale value is used to show them as integers.
A scale value is used only for representation to round up the values to the nearest constant. These
calculations can be done in floating point.
Zero-Crossing
After the LoG(x,y) matrix has been applied to the image a resulting image that consists of negative and
positive values. To find the edges of the image zero-processing will be performed in both left to right and
top to bottom of the image. When a cell that it adjacent to the right goes from positive to negative, or
negative to positive it will be marked as a zero-crossing pixel, and the resulting matrix will show that line.
The idea is to only show the locations where this does happen.
Zero-Crossing Matrix Theory:
The system calculates a zero crossing by checking a change in sign when the scanner moves from left to
right, or top to bottom. This can be easily achieved by multiplying the elements together and checking
their result. A negative result means the two elements are different and a zero crossing has occurred,
while a positive result means the pixels are the same type and a zero crossing has not occurred. This is
why if ((x,y) * (x+1,y ) < 0 is used in the example below.
Basic Example:
Pseudocode Example
Give SigmaValue, MaskSize
MatrixLoG = Calculate LapacianOfGaussian (SigmaValue, MaskSize)
M = convolution(MatrixLog, Image)
MatrixX = From M[x0..xn][y0..yn] if ((x,y) * (x+1,y ) < 0 store BLACK, else store WHITE
MatrixY = From M[x0..xn][y0..yn] if ((x,y) * (x,y+1) < 0) store BLACK, else store WHITE
MatrixComplete = For every element in MatrixX, and MatrixY if zero crossing has occurred store
BLACK, else store WHITE.
Results in =>
The examples in this text will show what the LoG(x,y) mask does to the image and the zero-crossings are
performed with that processed image.

10. 10
Project Results
LoG - Mask Size: 11x11 Sigma Value: 1.4
Scale Factor: 3000
0 0 0 0 1 2 1 0 0 0 0
0 0 2 6 10 12 10 6 2 0 0
0 2 9 20 30 32 30 20 9 2 0
0 6 20 33 19 1 19 33 20 6 0
1 10 30 19 -73 -143 -73 19 30 10 1
2 12 32 1 -143 -248 -143 1 32 12 2
1 10 30 19 -73 -143 -73 19 30 10 1
0 6 20 33 19 1 19 33 20 6 0
0 2 9 20 30 32 30 20 9 2 0
0 0 2 6 10 12 10 6 2 0 0
0 0 0 0 1 2 1 0 0 0 0
Below are the results of the photograph before zero-crossing with the images after convolution of the
kernel above has been performed on the image. The zero-crossing algorithm will use these images to
trace where an element goes from dark to light, or light to dark. These findings are recorded in a separate
image as the zero-crossings.
Zero-Crossing: when adjacent pixel changes from light to dark, or dark to light:

11. 11
LoG - Mask Size: 11x11 Sigma Value: 2.0
Scale Factor: 5000
1 2 4 6 8 9 8 6 4 2 1
2 5 9 12 13 13 13 12 9 5 2
4 9 13 12 7 4 7 12 13 9 4
6 12 12 0 -19 -30 -19 0 12 12 6
8 13 7 -19 -58 -76 -58 -19 7 13 8
9 13 4 -30 -76 -99 -76 -30 4 13 9
8 13 7 -19 -58 -76 -58 -19 7 13 8
6 12 12 0 -19 -30 -19 0 12 12 6
4 9 13 12 7 4 7 12 13 9 4
2 5 9 12 13 13 13 12 9 5 2
1 2 4 6 8 9 8 6 4 2 1
This sigma value appears to be too large for this mask’s dimensions.
The edge crossing images from this example remove more noise than the previous example. Detecting
the edges with this mask on the tomatoes image did not provide detailed lines. My assumptions are using
this sigma value without the right mask size may delete important lines within an image. (as seen here)
Zero-Crossing:

12. 12
LoG - Mask Size: 21x21 Sigma Value: 2.5
Scale Value: 100000
0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0
0 0 0 0 0 1 2 3 5 6 6 6 5 3 2 1 0 0 0 0 0
0 0 0 0 1 4 7 11 15 18 20 18 15 11 7 4 1 0 0 0 0
0 0 0 2 5 10 18 28 38 44 47 44 38 28 18 10 5 2 0 0 0
0 0 1 5 12 24 40 57 73 82 85 82 73 57 40 24 12 5 1 0 0
0 1 4 10 24 44 69 92 105 109 110 109 105 92 69 44 24 10 4 1 0
0 2 7 18 40 69 98 110 98 75 63 75 98 110 98 69 40 18 7 2 0
1 3 11 28 57 92 110 84 11 -73 -111 -73 11 84 110 92 57 28 11 3 1
1 5 15 38 73 105 98 11 -154 -327 -402 -327 -154 11 98 105 73 38 15 5 1
1 6 18 44 82 109 75 -73 -327 -583 -692 -583 -327 -73 75 109 82 44 18 6 1
1 6 20 47 85 110 63 -111 -402 -692 -814 -692 -402 -111 63 110 85 47 20 6 1
1 6 18 44 82 109 75 -73 -327 -583 -692 -583 -327 -73 75 109 82 44 18 6 1
1 5 15 38 73 105 98 11 -154 -327 -402 -327 -154 11 98 105 73 38 15 5 1
1 3 11 28 57 92 110 84 11 -73 -111 -73 11 84 110 92 57 28 11 3 1
0 2 7 18 40 69 98 110 98 75 63 75 98 110 98 69 40 18 7 2 0
0 1 4 10 24 44 69 92 105 109 110 109 105 92 69 44 24 10 4 1 0
0 0 1 5 12 24 40 57 73 82 85 82 73 57 40 24 12 5 1 0 0
0 0 0 2 5 10 18 28 38 44 47 44 38 28 18 10 5 2 0 0 0
0 0 0 0 1 4 7 11 15 18 20 18 15 11 7 4 1 0 0 0 0
0 0 0 0 0 1 2 3 5 6 6 6 5 3 2 1 0 0 0 0 0
0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0
The mask above has been generated into a 21 by 21 mask and starts at a sigma value of 2.5. This appears
to be the best choice for this mask because any larger of a sigma value the outer ring will start to be cutoff
by the mask dimensions.
This masked performed on a binary picture gives the following result:
Here is what the picture looks like with the 21x21 mask from above performed on the image:
The larger the sigma value is used, the larger the lines will be expanded in these photos. This should
show zero-crossings farther apart.
Zero Crossings:

13. 13
Larger Sigma produces larger line blocks:
LoG - Mask Size: 21x21 Sigma Value: 3.5
Scale Factor: 1000000
4 8 14 24 37 52 69 85 98 107 110 107 98 85 69 52 37 24 14 8 4
8 15 28 45 67 93 119 143 163 175 179 175 163 143 119 93 67 45 28 15 8
14 28 48 76 110 147 183 213 234 246 250 246 234 213 183 147 110 76 48 28 14
24 45 76 116 163 209 246 271 283 286 287 286 283 271 246 209 163 116 76 45 24
37 67 110 163 217 262 285 282 262 239 229 239 262 282 285 262 217 163 110 67 37
52 93 147 209 262 286 267 205 119 44 15 44 119 205 267 286 262 209 147 93 52
69 119 183 246 285 267 175 15 -172 -324 -383 -324 -172 15 175 267 285 246 183 119 69
85 143 213 271 282 205 15 -269 -585 -834 -929 -834 -585 -269 15 205 282 271 213 143 85
98 163 234 283 262 119 -172 -585 -1030 -1376 -1507 -1376 -1030 -585 -172 119 262 283 234 163 98
107 175 246 286 239 44 -324 -834 -1376 -1795 -1953 -1795 -1376 -834 -324 44 239 286 246 175 107
110 179 250 287 229 15 -383 -929 -1507 -1953 -2121 -1953 -1507 -929 -383 15 229 287 250 179 110
107 175 246 286 239 44 -324 -834 -1376 -1795 -1953 -1795 -1376 -834 -324 44 239 286 246 175 107
98 163 234 283 262 119 -172 -585 -1030 -1376 -1507 -1376 -1030 -585 -172 119 262 283 234 163 98
85 143 213 271 282 205 15 -269 -585 -834 -929 -834 -585 -269 15 205 282 271 213 143 85
69 119 183 246 285 267 175 15 -172 -324 -383 -324 -172 15 175 267 285 246 183 119 69
52 93 147 209 262 286 267 205 119 44 15 44 119 205 267 286 262 209 147 93 52
37 67 110 163 217 262 285 282 262 239 229 239 262 282 285 262 217 163 110 67 37
24 45 76 116 163 209 246 271 283 286 287 286 283 271 246 209 163 116 76 45 24
14 28 48 76 110 147 183 213 234 246 250 246 234 213 183 147 110 76 48 28 14
8 15 28 45 67 93 119 143 163 175 179 175 163 143 119 93 67 45 28 15 8
4 8 14 24 37 52 69 85 98 107 110 107 98 85 69 52 37 24 14 8 4
This final photograph shows many edge crossings all throughout the face. As sigma has been growing in
size, smaller elements have been becoming more pronounced in many of the later photos. I have found
that selecting a sigma value that expands nicely into the mask size works the best. This is the idea of
having all the elements that the LoG(x,y) produces without missing the outer edges of the Mexican hat
shape it makes. The larger the sigma value the thicker the edges appear to be when zero crossings are
performed on the image.