The HWB-RGB Transform Pair

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


#define RETURN_HWB(h, w, b) {HWB.H = h; HWB.W = w; HWB.B = b; return HWB;}

#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, W, B;} HWBType;

HWBType

RGB_to_HWB( RGBType RGB ) {

// RGB are each on [0, 1]. W and B are returned on [0, 1] and H is
// returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B.
float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f;
int i;
HWBType HWB;
w = min(R, G, B);
v = max(R, G, B);
b = 1 - v;
if (v == w) RETURN_HWB(UNDEFINED, w, b);
f = (R == w) ? G - B : ((G == w) ? B - R : R - G);
i = (R == w) ? 3 : ((G == w) ? 5 : 1);
RETURN_HWB(i - f /(v - w), w, b);

}


Note: The algorithm above for hue is essentially

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

where r = (v-R)/(v-w) etc. As in the note for hsv2rgb, this is the same as

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

The code above is easily changed to reflect this version.


RGBType

HWB_to_RGB( HWBType HWB ) {

// H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1].
// RGB are each returned on [0, 1]. NB, W + B <= 1 for valid RGB.
float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f;
int i;
RGBType RGB;
v = 1 - b;
if (h == UNDEFINED) RETURN_RGB(v, v, v);
i = floor(h);
f = h - i;
if (i & 1) f = 1 - f; // if i is odd
n = w + f * (v - w); // linear interpolation between w and v
switch (i) {
case 6:
case 0: RETURN_RGB(v, n, w);
case 1: RETURN_RGB(n, v, w);
case 2: RETURN_RGB(w, v, n);
case 3: RETURN_RGB(w, n, v);
case 4: RETURN_RGB(n, w, v);
case 5: RETURN_RGB(v, w, n);
}

}

Alvy's (my) Full Site