Question

My inner loop contains a calculation that profiling shows to be problematic.

The idea is to take a greyscale pixel x (0 <= x <= 1), and “increase its contrast”. My requirements are fairly loose, just the following:

• for x < .5, 0 <= f(x) < x
• for x > .5, x < f(x) <= 1
• f(0) = 0
• f(x) = 1 – f(1 – x), i.e. it should be “symmetric”
• Preferably, the function should be smooth.

So the graph must look something like this:

.

I have two implementations (their results differ but both are conformant):

float cosContrastize(float i) {
    return .5 - cos(x * pi) / 2;
}

float mulContrastize(float i) {
    if (i < .5) return i * i * 2;
    i = 1 - i;
    return 1 - i * i * 2;
}

So I request either a microoptimization for one of these implementations, or an original, faster formula of your own.

Maybe one of you can even twiddle the bits 😉

Answer 1

Trivially you could simply threshold, but I imagine this is too dumb:

return i < 0.5 ? 0.0 : 1.0;

Since you mention ‘increasing contrast’ I assume the input values are luminance values. If so, and they are discrete (perhaps it’s an 8-bit value), you could use a lookup table to do this quite quickly.

Your ‘mulContrastize’ looks reasonably quick. One optimization would be to use integer math. Let’s say, again, your input values could actually be passed as an 8-bit unsigned value in [0..255]. (Again, possibly a fine assumption?) You could do something roughly like…

int mulContrastize(int i) {
  if (i < 128) return (i * i) >> 7; 
  // The shift is really: * 2 / 256
  i = 255 - i;
  return 255 - ((i * i) >> 7);