{"id":2412,"date":"2019-06-19T19:24:19","date_gmt":"2019-06-19T18:24:19","guid":{"rendered":"https:\/\/ridgesolutions.ie\/?p=2412"},"modified":"2019-06-20T10:27:19","modified_gmt":"2019-06-20T09:27:19","slug":"a-faster-alternative-to-the-slow-getpixel-and-setpixel-for-net-bitmaps","status":"publish","type":"post","link":"https:\/\/www.ridgesolutions.ie\/index.php\/2019\/06\/19\/a-faster-alternative-to-the-slow-getpixel-and-setpixel-for-net-bitmaps\/","title":{"rendered":"A faster alternative to the very slow GetPixel() and SetPixel() for .Net System.Drawing.Bitmap"},"content":{"rendered":"
Anybody who works with images often have probably come across .Net Bitmaps (System.Drawing.Bitmap) with their staggeringly slow GetPixel() and SetPixel() methods. Now, if you are going to work directly with images then you’re probably in the wrong place if you are using C# and .Net. However, sometimes you may want to do a small amount image analysis or manipulation from within .Net without the pain of having to pull in any other image libraries – but you find that GetPixel() and SetPixel() are just way too slow to use!<\/p>\n
Now there is a faster way to access or manipulate the pixel data stored in a .Net Bitmap, that is to lock it (using LockBits()) and then directly access the raw image data in memory – you unlock it when you’re finished. This method is a lot faster than using Get\/SetPixel() but is quite complicated to implement and it’s very messy to look at!<\/p>\n
To get around this problem, and to avoid littering my code with gibberish I have written a bitmap wrapper class that wraps a bitmap, locks it, and provides it’s own GetPixel() and SetPixel() functions with which the original bitmap’s image data can be accessed. Using this class you can get fast access to a bitmap while using the familiar Get\/SetPixel() paradigm – in this way it should act as a fairly easy drop in replacement for accessing the Bitmap objects directly.<\/p>\n
The class is called BmpPixelSnoop and it is used like this:<\/p>\n
\r\n\/\/ Calculate a simple sum over all of the pixels\r\n\/\/ in the snooped bitmap. bitmap is a valid Bitmap object\r\n\r\nlong snoopSum = 0;\r\n\r\n\/\/ Create a BmpPixelSnoop wrapper for bitmap\r\nusing (var snoop = new BmpPixelSnoop(bitmap))\r\n{\r\n for (int j = 0; j != snoop.Height; j++)\r\n {\r\n for (int i = 0; i != snoop.Width; i++)\r\n {\r\n \/\/ We call GetPixel() on snoop rather\r\n \/\/ than bitmap as it's much faster!\r\n var col = snoop.GetPixel(i, j);\r\n\r\n snoopSum += col.R +\r\n col.G +\r\n col.B;\r\n }\r\n }\r\n}\r\n<\/pre>\n
First a BmpPixelSnoop object is created to wrap the bitmap, GetPixel() and SetPixel() can then be called on it. When the BmpPixelSnoop object is destroyed (on leaving the using() block) the original bitmap will be unlocked. It is important to note, that while the bitmap is being snooped the original bitmap object cannot be accessed as it’s locked! Currently BmpPixelSnoop only works for bitmaps with a Pixel Format of PixelFormat.Format32bppArgb which is the default format for Bitmaps (if you don’t specify an alternative when creating them).<\/p>\n
So for a little extra complication you get easy & fast access to the bitmap data – but how much faster than the native Get\/SetPixel() is it? My (non scientific) tests seem to indicate that it’s about 10 times faster, which is fast enough for simple imaging tasks. It is still quite inefficient however, this is a result of wanting to provide the same Get\/SetPixel() interface as System.Drawing.Bitmap – for example, GetPixel() always returns all of the pixel data even if you just want to access the red component and hence is slower than it needs to be in this case. I may add extra accessor methods in the future to cater for other usage patterns and greater efficiency.<\/p>\n