Jupiter's Blog

Creating an Image Processing Library with C# – Part 2

Creating an image Processing Library – Part 1

ASP.NET Demo Application

In the first post we covered the basics of Convolution operation and how it can be applied on an image. I posted an implementation (SafeImageConvolution) of the algorithm together with some helping classes we needed and the Sharpen filter. In this post, I'm going to show a much more efficient implementation of the algorithm. If you apply the Sharpening Filter from the previous post, using the SafeImageConvolution function, on a 1024x768, you will notice that it takes 6-7 seconds for the operation to complete. That’s, at least, unacceptable. The cause of this delay are the two GDI+ functions: Bitmap.GetPixel() and Bitmap.SetPixel().

So, here is a new implementation of the same algorithm. This time, i use pointer arithmetic to iterate through the image.

private static void ImageConvolution(Bitmap image, ConvMatrix fmat) {     if (fmat.Factor == 0)         return;     Bitmap srcImage = (Bitmap) image.Clone();          int x, y, filterx, filtery, tempx, tempy;     int s = fmat.Size / 2;     int r, g, b, tr, tg, tb;     int pixelSize = image.GetPixelSize();     BitmapData imageData = image.LockBits(new Rectangle(0,0,image.Width, image.Height), ImageLockMode.WriteOnly, image.PixelFormat);     BitmapData srcImageData = srcImage.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, image.PixelFormat);     int stride = srcImageData.Stride;     IntPtr scan0 = srcImageData.Scan0;     unsafe     {         byte* tempPixel;         for (y = s; y < srcImageData.Height - s; y++)         {             for (x = s; x < srcImageData.Width - s; x++)             {                 r = g = b = 0;                 for (filtery = 0; filtery < fmat.Size; filtery++)                 {                     for (filterx = 0; filterx < fmat.Size; filterx++)                     {                         tempx = x + filterx - s;                         tempy = y + filtery - s;                         tempPixel = (byte*)scan0 + (tempy * stride) + (tempx * pixelSize);                         tb = (int)*tempPixel;                         tg = (int)*(tempPixel + 1);                         tr = (int)*(tempPixel + 2);                         r += fmat.Matrix[filtery, filterx] * tr;                         g += fmat.Matrix[filtery, filterx] * tg;                         b += fmat.Matrix[filtery, filterx] * tb;                     }                 }                 r = Math.Min(Math.Max((r / fmat.Factor) + fmat.Offset, 0), 255);                 g = Math.Min(Math.Max((g / fmat.Factor) + fmat.Offset, 0), 255);                 b = Math.Min(Math.Max((b / fmat.Factor) + fmat.Offset, 0), 255);                 byte* newpixel = (byte*)imageData.Scan0 + (y * imageData.Stride) + (x * pixelSize);                 *newpixel = (byte)b;                 *(newpixel + 1) = (byte)g;                 *(newpixel + 2) = (byte)r;                 if (image.HasAlpha())                     *(newpixel + 3) = 255;             }         }     }     image.UnlockBits(imageData);     srcImage.UnlockBits(srcImageData); }

Let’s see some important points on the above code. First of all, the Bitmap.LockBits() locks the Bitmap to the memory and returns a BitmapData class which contains, among others, the following 2 properties that are later used: Scan0 and Stride. Scan0 is the address (IntPtr) of the first pixel in the bitmap. Stride is slightly more complicated to understand, but basically is the width of each row of pixels, rounded up to a 4-byte boundary. See the following image to better understand it:

If we have a 24bpp (= 3 Bytes per pixel) image with a width of 130 pixels then the actual pixel data on each row are 130 * 3 = 390 bytes, but the stride will be 392 (rounded up to 4-bytes). So we have 2 unused pixels on each row. Based on the above, to get the pixel at (X, Y) we can use the following formula:

pixel = Scan0 + (Y * Stride) + (X * PixelSize);

where PixelSize is the size of each pixel in bytes. This leads me to the second thing i want to explain on the code above.

You can see that i use the methods Bitmap.GetPixelSize() and Bitmap.HasAlpha(). As you may now, the Bitmap class doesn’t include these methods, i have implemented them as Extension methods and they can be found in the BitmapExtensions.cs file.

One last important thing to notice is that the pixels are saved in a BGR format, which means that Blue is the first byte, Green the second and Red the third (with a possible 4th byte for alpha channel).

You can find the whole source code, together with a Windows Forms demo application that uses the library. Feel free to send me any comments you have, suggestions or bugs that you may find.
 

Download