The HSV-RGB Transform Pair

The following routines are written in C (with C++ comments). See the closely related HWB-RGB Transform Pair.

#define RETURN_HSV(h, s, v) {HSV.H = h; HSV.S = s; HSV.V = v; return HSV;}

#define RETURN_RGB(r, g, b) {RGB.R = r; RGB.G = g; RGB.B = b; return RGB;}

#define UNDEFINED -1

// Theoretically, hue 0 (pure red) is identical to hue 6 in these transforms. Pure

// red always maps to 6 in this implementation. Therefore UNDEFINED can be

// defined as 0 in situations where only unsigned numbers are desired.

typedef struct {float R, G, B;} RGBType;

typedef struct {float H, S, V;} HSVType;

HSVType

RGB_to_HSV( RGBType RGB ) {

 // RGB are each on [0, 1]. S and V are returned on [0, 1] and H is // returned on [0, 6]. Exception: H is returned UNDEFINED if S==0. float R = RGB.R, G = RGB.G, B = RGB.B, v, x, f; int i; HSVType HSV; x = min(R, G, B); v = max(R, G, B); if(v == x) RETURN_HSV(UNDEFINED, 0, v); f = (R == x) ? G - B : ((G == x) ? B - R : R - G); i = (R == x) ? 3 : ((G == x) ? 5 : 1); RETURN_HSV(i - f /(v - x), (v - x)/v, v);

}

Note: The algorithm above for hue is essentially

H = (R==x)? 3+(g-b) : (G==x)? 5+(b-r) : 1+(r-g),

where r = (v-R)/(v-x) etc. Mr Yu Chun Fang of the Chinese Academy of Sciences noticed, in an email to me of 10 Nov 2000, that this is the same as

H = (R==v)? 0+(b-g) : (G==v)? 2+(r-b) : 4+(g-r).

He had seen my algorithm published in an unnamed Chinese book in this form. The forms are, indeed, equivalent.

Note added 8 July 2010: Richard C. Zulch points out that the Fang-reported version is not equivalent in one fine point: For pure red, my version gives H=6.0, but the other version gives H=0.0. Therefore the trick of using 0 for UNDEFINED does not work in that version.

Note added 28 July 2010: Daniel Seres generalizes the versions that lead to hue on [0, 6) rather than on (0, 6] as my original version has it. I quote him directly:

Replace lines:

f = (R == x) ? G - B : ((G == x) ? B - R : R - G); i = (R == x) ? 3 : ((G == x) ? 5 : 1); with lines:

f = (R == x) ? G - B : ((B == x) ? R - G : B - R); i = (R == x) ? 3 : ((B == x) ? 1 : 5);

Alternatively, you can also put lines:

i = (B == x) ? R - G : ((R == x) ? G - B : B - R); i = (B == x) ? 1 : ((R == x) ? 3 : 5); or even:

i = (B == x) ? R - G : ((G == x) ? B - R : G - B); i = (B == x) ? 1 : ((G == x) ? 5 : 3); the only criterion is:

in each second line, condition with a value of 1 must precede condition with a value of 5.

Practically, in the old version of the algorithm, which ends up calculating hue as

5 - (B - R) / (v - x), hue gets a value of 5 - (-1) = 6, in the "fixed" version of the algorithm, which ends up calculating hue as 1 - (R - G) / (v - x), hue becomes 1 - 1 = 0.

Thanks to all the contributors above. I think you get the idea on the variations that can lead to hue on [0, 6) or on (0, 6], the latter allowing you to use the UNDEFINED is 0 trick.

RGBType

HSV_to_RGB( HSVType HSV ) {

 // H is given on [0, 6] or UNDEFINED. S and V are given on [0, 1]. // RGB are each returned on [0, 1]. float h = HSV.H, s = HSV.S, v = HSV.V, m, n, f; int i; RGBType RGB; if (h == UNDEFINED) RETURN_RGB(v, v, v); i = floor(h); f = h - i; if ( !(i&1) ) f = 1 - f; // if i is even m = v * (1 - s); n = v * (1 - s * f); switch (i) { case 6: case 0: RETURN_RGB(v, n, m); case 1: RETURN_RGB(n, v, m); case 2: RETURN_RGB(m, v, n) case 3: RETURN_RGB(m, n, v); case 4: RETURN_RGB(n, m, v); case 5: RETURN_RGB(v, m, n); }

}

Alvy's (my) Full Site