About

For my 3rd year project, I decided to explore the preformace diferece between using the GPU and the CPU for image processing. I used CUDA to create a program that would take an image and apply a filter to it. I then compared the time it took to apply the filter using the CPU and the GPU.
During this process I reserched diferent image processing techniques and how their algorithms work. I then using this knowledge to implement the filters first in C++ and then in CUDA.
Because I used CUDA I also spent some time reserching GPU architecture and how to best use the GPU to get the best preformance.
The project was a great learning experience for me as I learned a lot about image processing and how to use the GPU to get the best preformance. I recived a 1st for the project and I am very proud of the work I did.

Filters

I implemented 2 filters for the project but I also created a few more which weren't used in the final project. The filters I implemented were:
Sobel
K-Means
Gaussian Blur
Diference of Gaussians

Sobel

The Sobel filter is a edge detecting filter which uses 2 3x3 kernels to detect the vertical and horizontal edges in an image. The filter works by convolving the image with the 2 kernels and then combining the results to get the final image. The resulting image is a black and white image with the edges of the original image highlighted with a gradient.
The filter can be improved by finding the local maxima of the gradient and then applying a threshold to the image to get a binary image with the edges highlighted. This is known as a Canny edge detector. I didn't implement this in my project but it is a common use of the Sobel filter.

K-Means

The K-Means filter is a clustering filter which groups the pixels in an image into K clusters. The filter works by randomly selecting K points in the image and then assigning each pixel to the cluster with the closest point. The filter then recalculates the points by finding the mean of the pixels in each cluster and then reassigning the pixels to the new clusters. This process is repeated until the points no longer change.
The filter can be improved by using a better initialisation method and by using a better distance metric to assign the pixels to the clusters. I used the Euclidean distance metric in my implementation but there are other distance metrics that could be used.

Gaussian Blur

The Gaussian Blure is the first filetr which I didnt include in my final project but I still implemented it. The filter works by convolving the image with a 2D Gaussian kernel. The kernel is a 2D array with the values of the Gaussian function. The filter works by multiplying the kernel with the image and then summing the results to get the final image.
This blure is an edge presurving blure which means that it will blure the image but it will try to keep the edges of the image sharp. This is done by using the Gaussian function which has a high value in the middle and low values at the edges.
This filter is often used in image processing to remove noise from the image as it presesrves the features of the image.

Diference of Gaussians

The Diference of Gaussians is the second filter which I didnt include in my final project but I still implemented it. The filter works by convolving the image with 2 Gaussian kernels and then subtracting the results to get the final image. The filter works by bluring the image with 2 different blures and then subtracting the results to get the edges of the image.
In my reserch I didn't initialy find this filter but I coincidentaly foind it when I descovered it's uses in styalising images. This process is described in the reserch paper entited "XDoG: An eXtended difference-of-Gaussians compendium including advanced image stylization" by Holger Winnemollera, Jan Eric Kyprianidisb and Sven C. Olsen

Results

At the end of the project I compaired the time it took to apply the filter on differently sized images usign both GPU and CPU implementations. I found that the GPU was much faster than the CPU for larger images but for smaller images the CPU was faster. This is because the GPU has a higher overhead than the CPU so for smaller images the overhead of transfering the image to the GPU was greater than the time it took to apply the filter on the CPU.
I also produced some graphs to show the time it took to apply the filter on the images. The graphs showed that the GPU was faster than the CPU for larger images but the CPU was faster for smaller images.