• Advertisement
Sign in to follow this  

colormath: Desaturation

This topic is 4369 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hi! I want to desaturate my colors in a shader... the question is: What's the most performant way to do desaturation? I thought about converting from RGB to HSV and then back to RGB but the formulas i found on wikipedia look a lil bit complex - so i don't think that this is the best way to do it... Every Hint is appreciated! Thx!

Share this post


Link to post
Share on other sites
Advertisement
Guest Anonymous Poster
I'm not a maths guru but seems to me that you can do something like this:

Greyscale Intensity = 0.3 * red + 0.59 * green + 0.11 * blue

so to desaturate you would just lerp:

new_pixel.R = Intensity * K + old_pixel.R * (1 - K)
new_pixel.G = Intensity * K + old_pixel.G * (1 - K)
new_pixel.B = Intensity * K + old_pixel.B * (1 - K)

so K would range from 0.0 to 1.0 where 0 gives new pixel = old pixel and 1.0 for fully desaturated.

If I'm off the mark then sorry: I was just heading off to bed for a much needed sleep.

(Watch the debate that will follow about the constants 0.3, 0.59, 0.11)

Share this post


Link to post
Share on other sites
sure? how can this be?? if you multiply plain white (1.0,1.0,1.0) with these values you get (0.3,0.59,0.11) which is green!?

Share this post


Link to post
Share on other sites
Quote:
Original post by genesys
sure? how can this be?? if you multiply plain white (1.0,1.0,1.0) with these values you get (0.3,0.59,0.11) which is green!?
No, you do a dot product of the color and (0.3, 0.59, 0.11) to get a grayscale intensity value. If you were converting to grayscale you would set each color channel to this intensity. What the AP was suggesting is to get this grayscale intensity and then linear interpolate between it and the original color to get your desaturation.

Share this post


Link to post
Share on other sites
Quote:
Original post by genesys
sure? how can this be?? if you multiply plain white (1.0,1.0,1.0) with these values you get (0.3,0.59,0.11) which is green!?


1 * .3 = .3
1 * .59 = .59
1 * .11 = .11
----------------+
intensity = .3 + .59 + .11 = 1

r = intensity
g = intensity
b = intensity

Share this post


Link to post
Share on other sites
if you're just trying to change the image into grayscale, I believe that taking the average of the r,g,b channels and replacing them with it, should work.

m = .33333f*(r+g+b);
r=g=b=m;

Share this post


Link to post
Share on other sites
Guest Anonymous Poster
Using the different weights for the red, green, and blue values (.3, .59, .11) might provide better looking results than just averaging the values, and since it is a dot product it might even be possible to calculate it as quickly as the average. The different values for each component reflect the eye's sensitivity to each color. A fully saturated green appears brighter than a fully saturated blue.

Share this post


Link to post
Share on other sites
In that case blend a little between the completely desaturated colour and the original colour. Do something like 0.9 * original_color + 0.1 * desaturated_color.

Share this post


Link to post
Share on other sites
oh ok! i understand!

taht's working :) thanks!

just one mor question: perhaps there is a less accurate but (for small saturation changes) working formula with less operations?

Share this post


Link to post
Share on other sites
For more colour manipulation ideas using interpolation/extrapolation, see the following: http://www.sgi.com/misc/grafica/interp/index.html

Quote:
just one mor question: perhaps there is a less accurate but (for small saturation changes) working formula with less operations?


The linear interpolations posted above can be done with a single pixel shader 1.1 instruction, you won't find much less than 1![smile]

HLSL:
const float3 coef = {0.3, 0.59, 0.11};
out.rgb = lerp(in.rgb, coef.rgb, amount);

PS1.1:
def c0, amount, 0, 0, 0
def c1, 0.3, 0.59, 0.11, 1
lrp r0.rgb, c0.r, r0.rgb, c1.rgb ; r0=input and output

Share this post


Link to post
Share on other sites
Guest Anonymous Poster
Quote:
The linear interpolations posted above can be done with a single pixel shader 1.1 instruction, you won't find much less than 1!

Share this post


Link to post
Share on other sites
Guest Anonymous Poster
Anonymous Poster: Not one instruction, you forgot to do the dot product:

(Without knowing exact HLSL syntax)

HLSL:
const float3 coef = {0.3, 0.59, 0.11};
out.rgb = lerp(in.rgb, dot3(coef.rgb, in.rgb), amount);


PS1.1:
def c0, amount, 0, 0, 0
def c1, 0.3, 0.59, 0.11, 1
; r0=input and output
dot3 r1.rgb, c1.rgb, r0.rgb
lrp r0.rgb, c0.r, r0.rgb, r1.rgb

Share this post


Link to post
Share on other sites
Quote:
Original post by Anonymous Poster
Anonymous Poster: Not one instruction, you forgot to do the dot product:

(Without knowing exact HLSL syntax)

HLSL:
const float3 coef = {0.3, 0.59, 0.11};
out.rgb = lerp(in.rgb, dot3(coef.rgb, in.rgb), amount);


PS1.1:
def c0, amount, 0, 0, 0
def c1, 0.3, 0.59, 0.11, 1
; r0=input and output
dot3 r1.rgb, c1.rgb, r0.rgb
lrp r0.rgb, c0.r, r0.rgb, r1.rgb


AP: Oops, my bad, yep you're quite right.


OP: So if you don't already have the luminance of the source image elsewhere in your shader, you'll have to dot the input colour against the coefficients to get it.

That said, luminance being scalar does open up some opportunities for co-issuing, so in most non-trivial pixel shaders, I'd still expect the whole desaturation operation to take only 1-1.5 effective instruction slots (or to be able to tag some extra functionality onto the operation to save elsewhere).

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement