Click here to Skip to main content
13,150,946 members (44,743 online)
Click here to Skip to main content
Add your own
alternative version


13 bookmarked
Posted 18 Jun 2012

Why the use of GetPixel and SetPixel is so inefficient!

, 12 Jul 2013
Rate this:
Please Sign up or sign in to vote.
Couple of seconds to process a one megapixel picture… what the hell?

The Bitmap class provides two simple methods: GetPixel and SetPixel used respectively to retrieve a point of image (as the Color structure) and set a point of image. The following code illustrates how to retrieve/set all the pixels in a bitmap:

private void GetSetPixel(Bitmap image) {
   for (int x = 0; x < image.Width; x++) {
      for (int y = 0; y < image.Height; y++) {
         Color pixel = image.GetPixel(x, y);
         image.SetPixel(x, y, Color.Black);

As shown, review and modification of pixels is extremely simple. Unfortunately, behind the simplicity of the code lies a serious performance trap. While for a small number of references to image points, the speed at which GetPixel and SetPixel work is good enough, for larger images it is not the case. The graph presented below can serve as a proof of that. It shows the results of 10 tests* which consisted of 10-fold invocation of previously shown GetSetPixel method for images 100x100 and 1000x1000 pixels in size.

Wyniki testów predkosci operacji na pikselach obrazu z uzyciem metod GetPixel i SetPixel klasy Bitmap.

The average test time for an image measuring 100 by 100 pixels was 543 milliseconds. This speed is acceptable if the image processing is not done frequently. The performance problem is, however, clearly visible when you try to use an image of size 1000 per 1000 pixels. The execution of the test in this case takes an average of more than 41 seconds - more than 4 sec. on a single call to GetSetPixel (seriously!).

Why so slow?

The low efficiency is due to the fact that access to the pixel is not a simple reference to a memory area. Each getting or setting of color is associated with the invocation of a .NET Framework method, which is a wrapper for a native function contained in gdiplus.dll. This call is through the mechanism of P/Invoke (Platform Invocation), which is used to communicate from managed code to unmanaged API (an API outside of the .NET Framework). So for a bitmap of 1000x1000 pixels, there will be 1 million calls to the GetPixel method that besides the validation of parameters uses the native GdipBitmapGetPixel function. Before returning the color information, the GDI+ function has to perform such operations as calculating the position of bytes responsible for the description of the desired pixel… A similar situation occurs in the case of the SetPixel method.

Look at the following code of the Bitmap.GetPixel method obtained with the .NET Reflector (System.Drawing.dll, .NET Framework 2.0):

public Color GetPixel(int x, int y) {
   int argb = 0;
   if ((x < 0) || (x >= base.Width)) {
      throw new ArgumentOutOfRangeException("x", SR.GetString("ValidRangeX"));
   if ((y < 0) || (y >= base.Height)) {
      throw new ArgumentOutOfRangeException("y", SR.GetString("ValidRangeY"));
   int status = SafeNativeMethods.Gdip.GdipBitmapGetPixel
    (new HandleRef(this, base.nativeImage), x, y, out argb);
   if (status != 0) {
      throw SafeNativeMethods.Gdip.StatusException(status);
   return Color.FromArgb(argb);

Here is the import of the GDI + function:

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, SetLastError=true, 
internal static extern int GdipBitmapGetPixel(HandleRef bitmap, int x, int y, out int argb);

* I have tested on this laptop: HP Pavilion dv5, AMD Turion X2 Dual-Core Mobile RM-70, 3 GB RAM, Vista Home Premium

Update (10.07.2013): Unfortunately I haven't found time to write an article about a solution to this performance problem but there are some useful hints in my comment.

Update (07.11.2013): I've written an article (...finally) about fast pixel operations. No need to use crappy Get/SetPixel anymore :) Click here.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

You may also be interested in...


Comments and Discussions

GeneralMy vote of 5 Pin
GregoryW11-Jul-13 2:40
memberGregoryW11-Jul-13 2:40 
GeneralMy vote of 5 Pin
Volynsky Alex10-Jun-13 1:30
memberVolynsky Alex10-Jun-13 1:30 
QuestionFast access Pin
YvesDaoust9-Jun-13 23:34
memberYvesDaoust9-Jun-13 23:34 
AnswerRe: Fast access Pin
morzel10-Jun-13 0:21
membermorzel10-Jun-13 0:21 
GeneralRe: Fast access Pin
KP Lee19-Jun-13 19:11
memberKP Lee19-Jun-13 19:11 
GeneralRe: Fast access Pin
morzel20-Jun-13 1:26
membermorzel20-Jun-13 1:26 
GeneralRe: Fast access Pin
KP Lee20-Jun-13 20:28
memberKP Lee20-Jun-13 20:28 
GeneralRe: Fast access Pin
Klaus-Werner Konrad11-Jul-13 3:16
memberKlaus-Werner Konrad11-Jul-13 3:16 
QuestionWorkaround would be useful Pin
MR_SAM_PIPER18-Jun-12 13:43
memberMR_SAM_PIPER18-Jun-12 13:43 
AnswerRe: Workaround would be useful Pin
Chona117119-Jun-12 3:17
memberChona117119-Jun-12 3:17 
AnswerRe: Workaround would be useful - code sample Pin
morzel20-Jun-12 4:47
membermorzel20-Jun-12 4:47 
GeneralMy vote of 5 Pin
SledgeHammer0118-Jun-12 10:21
memberSledgeHammer0118-Jun-12 10:21 
GeneralRe: My vote of 5 Pin
WiStRoM11-Jul-13 4:49
memberWiStRoM11-Jul-13 4:49 
Many times I am also advisied to not use GetPixel/SetPixel similar functions. And also such viewpoints appear in many outstanding books, such as Charles Petzold’s <<windows programming- fifith edition.>>. Of course, we can prove it as the author does, but no one dig deep into the win32 API GetPixel/SetPixel, and which reason cause the bottleneck of Such API,software or hardware?

From my limit hardware experience, here is some of my guess. To get one pixel of the bitmap, GetPixel/SetPixel API have to access the GPU memory each time. and each call to GetPixel/SetPixel API requires lots of communication between CPU,Memory,Northbridge,SourthBridget chipset. The actual data required only one pixel, but we have to suffer the overhead of each communication. So, to improve the efficiency of communication, we can try to access more GPU memory one time as possible.

I'm not sure my above guess is correct or wrong, does anyone can explain it in depth with good evidence? Thanks~ Big Grin | :-D Big Grin | :-D

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.170924.2 | Last Updated 12 Jul 2013
Article Copyright 2012 by morzel
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid