Faster contrast algorithm for a bitmap

Question

I have a tool with trackbar slider controls used to adjust an image's brightness, contrast, gamma, etc.

I am trying to get real-time updates to my image while the user drags the slider. The brightness and gamma algorithms are an acceptable speed (around 170ms). But the contrast algorithm is about 380ms.

Basically my form is a tool window with sliders. Each time the image is updated, it sends an event to the parent which redraws the new image. The tool window keeps the original unmodified image locked in memory so I always have access to the bytes of it. So basically I do this each time the ValueChanged event for a slider (such as the Contrast slider) is changed.

• LockBits of the working (destination) bitmap as Format24bppRgb (original bitmap is in Format32bppPArgb)
• Marshal.Copy the bits to a byte[] array
• Check which operation I'm doing (which slider was chosen)
• Use the following code for Contrast:

Code:

double newValue = 0;
double c = (100.0 + contrast) / 100.0;

c *= c;

for (int i = 0; i < sourcePixels.Length; i++)
{
    newValue = sourcePixels[i];

    newValue /= 255.0;
    newValue -= 0.5;
    newValue *= c;
    newValue += 0.5;
    newValue *= 255;

    if (newValue < 0)
        newValue = 0;
    if (newValue > 255)
        newValue = 255;

    destPixels[i] = (byte)newValue;
}

I read once about using integer instead of floating point values to increase the speed of contrast, but I couldn't find that article again.

I tried using unsafe code (pointers) but actually noticed a speed decrease. I assume it was because the code was using nested for loops to iterate x and y instead of a single loop.

Answer 1

Depending on the machine you're running this on, your technique could be quite slow. If you're using an ARM system without an FPU, each of those operations would take quite a while. Since you're applying the same operation to every byte, a faster technique would be to create a 256-entry lookup table for the contrast level and then translate each image byte through the table. Your loop would then look like:

byte contrast_lookup[256];
double newValue = 0;
double c = (100.0 + contrast) / 100.0;

c *= c;

for (int i = 0; i < 256; i++)
{
    newValue = (double)i;
    newValue /= 255.0;
    newValue -= 0.5;
    newValue *= c;
    newValue += 0.5;
    newValue *= 255;

    if (newValue < 0)
        newValue = 0;
    if (newValue > 255)
        newValue = 255;
    contrast_lookup[i] = (byte)newValue;
}

for (int i = 0; i < sourcePixels.Length; i++)
{
    destPixels[i] = contrast_lookup[sourcePixels[i]];
}