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); | ||
| } | ||
}