Trudging Unknown Waters: Image Registration

It has been some time since my last post. Even after one year of blogging, the phenomenon called Writer's Block has intrigued me. There are times when it is difficult to come up with a post for days and then there are times when one comes up with posts back to back. Very difficult to understand unless one really faces it first hand.

It has also been quiet a hectic time. Life in IIT is not all that rosy as it is made out to be. I have been involved with a project on 3D deformable image registration using GPU. Here is an example of an image registration (2D) that I did using MATLAB.

What is Image Registration?

For those not in the know, I have used a very well known image in Image Processing - that of Lena Soderberg. It is often used as a standard test image. The first image is a deformed one (also known as the moving image) and the second is the static image. The moving image has to be transformed to match with the static image which is the result (the third image - the registered image).

Applications

One often uses image registration in medical imaging. Instead of a face, one might have a deformed state of the human lung. That becomes the moving image. It can then be transformed to match with a human lung in the normal state. This way one can integrate the data and work on the human lung.

As the wikipedia defines it, Image Registration is the process of transforming different sets of data into one coordinate system.

Image registration is not confined to medical imaging alone. It is a widely used technique in astrophotography and panoramic photography.

The Challenge

The image that I have used is a grayscale image of dimensions 512 x 512. Image registration algorithms require that you work pixel by pixel and iterate over the operations 100 to 200 times. This means each operation within the loop has to performed 512 x 512 x 200 = 52428800 times which can be computationally very expensive (This image took me 3 to 4 minutes)

This is where my project comes in - to parallelize the code. Instead of the operations on individual pixels running serially, they can be made to run in parallel by making use of the Graphics Processing Unit (GPU) [The NVidia G80 has 16 multiprocessors and each multiprocessor is composed of 8 processors (ALUs).  That is one too many compared to what Intel has to offer].

Parallelizing the code has been used to achieve a speedup of upto 55 times in many applications. This can very useful in image registration, specially in medical applications where time is of prime importance.

The GPU is not the only way to do it - there are other ways too (FPGA based for example). However, image registration using the GPU is a fairly new domain and it is going to be exciting to see how the GPU fairs in comparison to the existing procedures.

P.S: Was this post too technical in nature? Have any ideas for me too write on? You can let me know in the comments section :)