Wednesday, 5 May 2021

Colour Pick 3: WebGL

If you look in the bottom-left corner of the Colour Pick experiment web page, you'll see a checkbox:

Colour Pick WebGL checkbox

This is an optimization. It turns out that updating even a few canvases interactively whilst the user is dragging the mouse can produce very "laggy" responses. The problem is that some of the canvases draw non-trivial shapes with each pixel's colour computed on-the-fly. For example:

CIE L*a*b* gamut canvas

The canonical way of updating a single pixel in a canvas via JavaScript is something akin to this:

var context = canvas.getContext("2d");
context.fillStyle = rgb;
context.fillRect(x, y, 1, 1);

This is fine for a few pixels but doesn't scale well. WebGL fragment shaders, on the other hand, are ideal for updating rectangular regions like this on a pixel-by-pixel basis. However, you cannot use both "2d" and "webgl" contexts on the same canvas. Consequently, the JS script, uses an off-screen "webgl" canvas to utilise fragment shaders and then "blits" the result to the on-screen canvas.

WebGL fragment shaders are only guaranteed to conform to OpenGL Shader Language (GLSL) version 1.00, so you have to be a bit conservative with your shader programming sometimes.

The "FRAGMENT_SHADER_SOURCE" variable at the top of the colourpick.js script contains the interesting GLSL code to perform the various colour space conversions.

The first function converts an HSL/HSV-style hue in the range zero to one into a fully-saturated RGB triple:

vec3 hue2rgb(float h) { float r = abs(h * 6.0 - 3.0) - 1.0; float g = 2.0 - abs(h * 6.0 - 2.0); float b = 2.0 - abs(h * 6.0 - 4.0); return clamp(vec3(r, g, b), 0.0, 1.0); }

The next function converts a red/green/blue triple to hue/chroma/value based on the work by Sam Hocevar and Emil Persson:

vec3 rgb2hcv(vec3 rgb) { vec4 p = (rgb.g < rgb.b) ? vec4(rgb.bg,-1.0,2.0/3.0) : vec4(rgb.gb,0.0,-1.0/3.0); vec4 q = (rgb.r < p.x) ? vec4(p.xyw, rgb.r) : vec4(rgb.r, p.yzx); float c = q.x - min(q.w, q.y); float h = abs((q.w - q.y) / (6.0 * c + 1.0e-10) + q.z); return vec3(h, c, q.x); }

Next we have our first true colour space conversion: HSV to RGB:

vec3 hsv2rgb(vec3 hsv) { vec3 rgb = hue2rgb(hsv.x); return ((rgb - 1.0) * hsv.y + 1.0) * hsv.z; }

HSL to RGB is similar:

vec3 hsl2rgb(vec3 hsl) { vec3 rgb = hue2rgb(hsl.x); return (rgb - 0.5) * (1.0 - abs(2.0 * hsl.z - 1.0)) * hsl.y + hsl.z; }

HWB (hue/whiteness/blackness) to RGB is also similar:

vec3 hwb2rgb(vec3 hwb) { vec3 rgb = hue2rgb(hwb.x); return rgb * (1.0 - hwb.y - hwb.z) + hwb.y; }

Converting "linear" RGB to sRGB requires component-wise conditionals. I'd love to be able to use 'vec3 mix(vec3, vec3, bvec3)' here, but basic WebGL doesn't support it, so we have to make sure that both "branches" of the conditional are finite:

vec3 lrgb2srgb(vec3 rgb) { vec3 linear = rgb * 12.92; vec3 nonlinear = 1.055 * pow(max(rgb, 0.0), vec3(1.0 / 2.4)) - 0.055; return mix(nonlinear, linear, vec3(lessThan(linear, vec3(0.04045)))); }

Converting CIE XYZ to linear RGB is a simple matrix multiplication, but basic WebGL doesn't support constant matrix initialization:

vec3 xyz2lrgb(vec3 xyz) { return vec3(dot(xyz, vec3(+3.2404542, -1.5371385, -0.4985314)), dot(xyz, vec3(-0.9692660, +1.8760108, +0.0415560)), dot(xyz, vec3(+0.0556434, -0.2040259, +1.0572252))); }

We have to avoid division by zero when converting CIE xyY to CIE XYZ:

vec3 xyy2xyz(vec3 xyy) { float d = xyy.z / max(xyy.y, 1.0e-10); return vec3(xyy.x * d, xyy.z, (1.0 - xyy.x - xyy.y) * d); }

We assume a D65 illuminant and a 2-degree standard colormetric observer for converting CIE L*a*b* to CIE XYZ. Again, it would be nice to use 'vec3 mix(vec3, vec3, bvec3)' in the final statement, but basic WebGL doesn't support it:

vec3 lab2xyz(vec3 lab) { float fy = (lab.x + 16.0) / 116.0; float fx = fy + lab.y * 0.002; float fz = fy - lab.z * 0.005; vec3 fxyz = vec3(fx, fy, fz); vec3 linear = (fxyz * 3132.0 - 432.0) / 24389.0; vec3 nonlinear = fxyz * fxyz * fxyz; return mix(nonlinear, linear, vec3(lessThan(nonlinear, vec3(216.0 / 24389.0)))) * vec3(0.95047,1.0,1.08883); }

Converting CIE LCHab to CIE L*a*b* is a simple polar-to-cartesian conversion:

vec3 lchab2lab(vec3 lch) { float hab = radians(lch.z); return vec3(lch.x, lch.y * cos(hab), lch.y * sin(hab)); }

As is converting CIE LCHuv to CIE LUV (it's actually identical, but we'll keep it distinct):

vec3 lchuv2luv(vec3 lch) { float huv = radians(lch.z); return vec3(lch.x, lch.y * cos(huv), lch.y * sin(huv)); }

Converting CIE LUV to CIE XYZ is relatively straightforward (assuming D65 and 2-degrees observer):

vec3 luv2xyz(vec3 luv) { float p = luv.x * 52.0 / (luv.y + luv.x * 2.571917722678301); float q = luv.x * 39.0 / (luv.z + luv.x * 6.088371938121326); float y = (luv.x > 8.0) ? pow((luv.x + 16.0)/116.0, 3.0) : (luv.x * 27.0/24389.0); float x = y * q * 3.0 / p; float z = x * (p - 1.0) / 3.0 - y * 5.0; return vec3(x, y, z); }

As noted in the previous post, "hue" in CIE LChab is not the same as "hue" in HSL/HSV/HWB. The following function provides a very close approximation of the latter when given the former without having to perform the complete LChab→LabXYZRGBsRGBHSL calculation chain. Note that both hues are in the range [0..1]:

float hab2hue(float hab) { const vec4 a = vec4(0.011681489, -0.053365543, -0.00331377, -0.009398634); const vec4 b = vec4(-0.527823872, -1.606202694, 1.054897946, 0.102411421); const float c = 0.91047088; vec4 v = sin(vec4(1.0, 2.0, 3.0, 4.0) * hab * 6.28318530718 + b); return fract(hab + dot(a, v) + c); }

The CIE LChuv hue to HSL/HSV/HWB hue conversion needs a few more terms in the expansion to be accurate. Again, both hues are in the range [0..1]:

float huv2hue(float huv) { const vec4 a03 = vec4(0.003125388, -0.033086796, 0.007706313, 0.004791156); const vec4 a47 = vec4(0.001477559, 0.001918466, -0.000558722, 0.001325); const vec4 b03 = vec4(0.006280978, -0.762775675, -0.798412429, -1.390621155); const vec4 b47 = vec4(1.509991161, -1.395042259, 1.09539382, 0.731749525); const float c = 0.957463921; vec4 v03 = sin(vec4(1.0, 2.0, 3.0, 4.0) * huv * 6.28318530718 + b03); vec4 v47 = sin(vec4(5.0, 6.0, 7.0, 8.0) * huv * 6.28318530718 + b47); return fract(huv + dot(a03, v03) + c); }

The functions above give you the building blocks necessary to convert most colour space points into RGB. The reverse transformations are left as an exercise for the reader. [Hint: I've previously written some of them in HLSL]

On my PC, using offscreen WebGL techniques speeds up the rendering of all the colour picker canvases by a factor of about twelve which means the response times go from "annoyingly sluggish" to "unnoticeably fast".


Thursday, 1 April 2021

Colour Pick 2: History

Pick a colour, any colour. Now tell me what colour you've chosen.

It's surprisingly difficult to:

  1. Design a user interface to allow someone to intuitively pick a colour, and
  2. Come up with a description of colours that is meaningful to both humans and computers.
If we ask a browser to ask the user to pick a colour, we get a control like this:

Depending on your browser, you may get a dialog like this:

Colour input dialog from Google Chrome 89 (2021)

Chrome allows you to switch between RGB, HSL and hexadecimal input schemes. The "result" of the dialog is an HTML hexadecimal colour in the format "#rrggbb", e.g. "#DAA520".

Is that the state of the art? The Colour Pick experiment is a personal investigation into user interfaces like this.

A Bit of History

One of the first graphical editing programs was Sketchpad (1963) but this was designed for a monochrome vector display.

According to Alvy Ray SmithWilliam Kubitz (1968) and Joan Miller (1969) both created hardware with eight fixed colours, presumably black, blue, red, magenta, green, cyan, yellow and white.

Until SuperPaint (1973) appeared with its 256-entry, 24-bit RGB palette, the number of colours available meant that a "palette box" was sufficient for most software. SuperPaint introduced the ability to specify a colour via HSB (HSV) sliders:

SuperPaint tool palette (1973)

The first PC graphics software used palette boxes because of the colour limitations of early graphics cards such as CGA/EGA:

PCPaint+ (1985)

Meanwhile, Apple software was at a similar stage with MacPaint.

With the advent of 24-bit colour hardware on home and office computers, techniques for picking colours "caught up" with professional image- and video-editing systems. Mechanisms that used the RGB, HSV and HSL colour spaces became the norm:

Paint Shop Pro 5 (1998)

The CIE L*a*b* and related colour spaces started to appear in pickers too:

Adobe Photoshop (after 1990)

Although Microsoft remains stubbornly old-school:

Microsoft Paint for Windows 10 (2020)

Apple's current colour picker has multiple tabs; the first is an HSV circle picker:

Apple Color Picker (2020)

An interesting variation on the HSV circle is the discrete hexagonal palette popular on Windows:

Mechanika Design (2015)

GIMP has a number of built-in colour pickers. The "triangle wheel" is described in the documentation as based on HSV, but it looks more like HWB to me:

GIMP 2.10.22 (2020)

I've tried to systematically encapsulate as many of these ideas as possible in the Colour Pick web page.

Monday, 29 March 2021

Intern Ethel P

I've just received a very suspicious email from "internethelp@<[-redacted-].com". It purports to be assistance for a query I had with an online service. But I know better! It's just another blatant phishing scam by that master cyber-criminal intern Ethel P.

Friday, 26 March 2021

Colour Pick 1: Goldenrod

As part of my investigation into colour names, I've been writing a lot of JavaScript code to perform colour space transformations.

When I started the colour pick work, I did the "right thing" and refactored all the colour-related functionality into a library. The library is named "goldenrod" after the X11 colour of that name (#DAA520).

Solidago virgaurea minuta "Dwarf Goldenrod"

The library is just a plain old bunch of functions and lists organised into three files:

goldenrod.js

This script contains the main entry points exposed as fields of the global object "chilliant.goldenrod". They are primarily conversion functions with signatures of the following form:

float[3] chilliant.goldenrod.{source}_to_{destination}(float value[3])

Above, "{source}" and "{destination}" are colour space tags as listed in the following table:

TagColour Spacevalue[0]value[1]value[2]
sRGBsRGBred
0.0 to 1.0
green
0.0 to 1.0
blue
0.0 to 1.0
HSVHSV
a.k.a. HSB
hue
0.0 to 360.0 degrees
saturation
0.0 to 1.0
value
0.0 to 1.0
HSLHSLhue
0.0 to 360.0 degrees
saturation
0.0 to 1.0
lightness
0.0 to 1.0
HWBHWBhue
0.0 to 360.0 degrees
whiteness
0.0 to 1.0
blackness
0.0 to 1.0
CIEXYZCIE 1931 XYZX
0.0 to 1.0
Y luminance
0.0 to 1.0
Z
0.0 to 1.0
CIExyYCIE 1931 xyYx
0.0 to 100.0
y
0.0 to 100.0
Y luminance
0.0 to 100.0
CIELabCIE 1976 L*a*b*L* lightness
0.0 to 100.0
a*
~ -100.0 to 100.0
b*
~ -100.0 to 100.0
CIELuvCIE 1976 L*u*v*L* lightness
0.0 to 100.0
u*
~ -200.0 to 200.0
v*
~ -200.0 to 200.0
CIELChabCIE 1976 L*C*habL* lightness
0.0 to 100.0
C* chroma
~ 0.0 to 100.0
hab hue
0.0 to 360.0 degrees
CIELChuvCIE 1976 L*C*huvL* lightness
0.0 to 100.0
C* chroma
~ 0.0 to 100.0
huv hue
0.0 to 360.0 degrees

Note that for conversions to and from the hexacone colour spaces (HSV/HSL/HWB) the tag "RGB" is used instead of "sRGB" to emphasize the fact that no linearization or delinearization is performed. Thus, the name "chilliant.goldenrod.RGB_to_HSL" is used instead of "chilliant.goldenrod.sRGB_to_HSL".

All conversions assume a standard D65 illuminant with a two-degree observer angle.

At the time of writing, not all permutations of source and destination are directly supported, but it's a trivial change to add the missing "chains".

The additional members of "chilliant.goldenrod" are listed below.

bool chilliant.goldenrod.within_sRGB(any srgb)

A function that returns true if, and only if, 'srgb' is an array of at least three numbers all between 0.0 and 1.0 inclusive.

float[3] chilliant.goldenrod.force_sRGB(any srgb)

Forces 'srgb' to be a valid sRGB triplet with each element between 0.0 and 1.0. If any channel is greater than one, the whole triplet is scaled back. If 'srgb' cannot be interpretted as a valid triplet, black [0,0,0] is returned.

float chilliant.goldenrod.deltaE1994(float ref[3], float lab[3])

Computes the CIELAB ΔE*(1994) colour difference between the two CIEL*a*b* colours. Note that this metric is not symmetric.

float chilliant.goldenrod.deltaE2000(float ref[3], float lab[3])

Computes the CIELAB ΔE*(2000) colour difference between the two CIEL*a*b* colours.

string chilliant.goldenrod.sRGB_to_HEX(float srgb[])

Converts the sRGB triplet (or quartet with alpha) 'srgb' to a hexadecimal colour in the form "#rrggbb" or "#rrggbbaa".

float[3] chilliant.goldenrod.HEX_to_sRGB(string hex)

Converts an hexadecimal colour string in the form "#rgb", "#rgba", "#rrggbb" or "#rrggbbaa" into an sRGB triplet. Any alpha component is ignored.

string chilliant.goldenrod.version

A string field containing the goldenrod library version in semver format, e.g. "1.0.0".

util.js

This script contains the guts of the functionality of goldenrod exposed as members of the object "chilliant.goldenrod.util". A large portion is based on the formulae outlined on Bruce Lindbloom's excellent site and should be fairly self-explanatory.

data.js

This script contains useful datasets exposed as members of the object "chilliant.goldenrod.data".

float[][] chilliant.goldenrod.data.cie1931_xyy

The CIE 1931 2-degree chromaticity xyY coordinates from UCL Colour & Vision Research Laboratory. The columns are:

  1. Wavelength in nm,
  2. CIE xyY x-ordinate,
  3. CIE xyY y-ordinate, and
  4. CIE xyY Y luminance.

object[] chilliant.goldenrod.data.css4

The CSS 4 colour names taken from Mozilla.

any[] chilliant.goldenrod.data.centore

The 267 ISCC-NBS centroids from Paul Centore's site in index order. The columns are:

  1. Name (string),
  2. Munsell colour (string),
  3. Red (int),
  4. Green (int),
  5. Blue (int),
  6. sRGB hexadecimal (string).

Note that seven of the centroids are outside the sRGB gamut so are missing the final four columns. It would be nice to have the out-of-gamut values for red/green/blue because those points could still be matched via (for instance) Euclidean distance searchers. However, I have been unable to recreate Paul's methodology to fill in the blanks.

object chilliant.goldenrod.data.cns

A 627-entry map between the Color Naming System and sRGB values in the form:

{
  "black": {hex: "#000000", srgb: [0,0,0]},
  ...
  "yellowish orange": {hex: "#CC9333", srgb: [0.8,0.575,0.2]}
}

This is a "best guess" at the values based on "A New Color-Naming System for Graphics Languages".

See "generateCNS()" for details.

any[] chilliant.goldenrod.data.iscc

The 260 ISCC-NBS centroids from "data.centore" that are within the sRGB gamut, formatted like "data.cns".

See "generateISCC()" for details.

Unit Tests

The goldenrod library has a minimal unit test suite. The values were checked against Bruce Lindbloom's colour calculator, amongst other tools.

Tuesday, 23 March 2021

HSL and CIELCh(ab) Hue Wheels

I've been looking at colour pickers recently and came across (what I think is) an interesting cul-de-sac.

HSL colour pickers often have a hue wheel similar to this one from Paint Shop Pro 5 (1998):

Paint Shop Pro 5 colour picker dialog

The wheel is rendered as an angle sweeps from 0 to 360 degrees clockwise:

output = HSL_to_RGB(angle, 100%, 50%)

The HSL wheel looks like this:

HSL hue wheel

Note that the "hue" components of HSL, HSV and HWB are identical. However, this is not the case for the cylindrical version of CIE Lab, a.k.a. CIELCh(ab).

We can construct the CIELCh(ab) hue wheel as follows:

rgb = CIELChab_to_sRGB(70, 30, angle)
hsl = RGB_to_HSL(rgb)
output = HSL_to_RGB(hsl.h, 100%, 50%)

We choose a CIE perceptual lightness (L*) of 70 and chroma (C*) of 30 so as not to go out-of-gamut when converting to sRGB. We also implicitly assume the reference white to be the CIE standard illuminant D65 and a 2-degree observer angle.

We use HSL to fully saturate the output colour to produce the following wheel:

CIELCh(ab) hue wheel

Note that the colours have shifted somewhat. This becomes clear if we plot both wheels on the same chart:

HSL (outer) and CIELCh(ab) (inner) hue wheels

There's already an excellent comparison of these two wheels by Elle Stone, so I won't go into that here.

For reasons that will hopefully become clear in a later post, what I really wanted to do was plot the CIELCh(ab) hue wheel efficiently in WebGL. Who wouldn't?

I coded "CIELChab_to_sRGB" et al in GLSL (more on that later too) but felt a bit queasy performing such complicated arithmetic, particularly when the results get shunted through an RGB-HSL-RGB hack at the end. There must be an efficient way of translating CIELCh(ab) hue to HSL hue, surely?

If we plot the relationship, we get:

CIELCh(ab) hue versus HSL hue

I looks like a fairly linear albeit wavy relationship, doesn't it? So let's plot the difference modulo 360 degrees:

Difference in hues modulo 360 degrees

It now looks fairly sinusoidal, so maybe we can approximate it with the sum of a few sine waves.

If the input is the CIELCh(ab) hue angle in degrees and the desired output is the HSL hue, we can write:

output = input + c + a0*sin(b0+input) + a1*sin(b1+2*input) + a2*sin(b2+3*input) + …

It turns out you only need four sine terms to get a good approximation and Microsoft Excel Solver is more that capable of finding appropriate values for the offset "c", scale factors "a0" to "a3" and phase shifts "b0" to "b3".

I initially coded the formula as a GLSL function that takes the hues in the range zero to one, like so:

float hstar2hue(float input) {
  // Convert CLIELCh(ab) hue [0..1] to HSV/HSL/HWB hue [0..1]
  float a0 = 0.011681489;
  float a1 = -0.053365543;
  float a2 = -0.00331377;
  float a3 = -0.009398634;
  float b0 = -0.527823872;
  float b1 = -1.606202694;
  float b2 = 1.054897946;
  float b3 = 0.102411421;
  float c = 0.91047088;
  float output = input + c;
  output += a0 * sin(b0 + input * 2.0 * 3.1415926536);
  output += a1 * sin(b1 + input * 4.0 * 3.1415926536);
  output += a2 * sin(b2 + input * 6.0 * 3.1415926536);
  output += a3 * sin(b3 + input * 8.0 * 3.1415926536);
  return mod(output, 1.0);
}

But we can take advantage of GLSL's SIMD nature and get:

float hstar2hue(float input) {
  // Convert CLIELCh(ab) hue [0..1] to HSV/HSL/HWB hue [0..1]
  vec4 a = vec4(0.011681489, -0.053365543, -0.00331377, -0.009398634);
  vec4 b = vec4(-0.527823872, -1.606202694, 1.054897946, 0.102411421);
  float c = 0.91047088;
  vec4 v = sin(vec4(1.0, 2.0, 3.0, 4.0) * input * 6.28318530718 + b);
  return mod(input + dot(a, v) + c, 1.0);
}

It's then just a question of converting the HSL-style hue to RGB:

vec3 hue2rgb(float h) {
  float r = abs(h * 6.0 - 3.0) - 1.0;
  float g = 2.0 - abs(h * 6.0 - 2.0);
  float b = 2.0 - abs(h * 6.0 - 4.0);
  return clamp(vec3(r, g, b), 0.0, 1.0);
}

And we've got all the ingredients for a fragment shader to render the CIELCh(ab) hue wheel.

I'll leave it as an exercise for the reader to work out the reverse HSL-to-CIELCh(ab) hue approximation as well as those for CIELCh(uv).

Friday, 5 March 2021

Colour Names 5

Still more colour naming experiments...

My experiments with HWB-51 last time divided up the whiteness-blackness plane for a particular hue (e.g. blue) like this:

Partitioning the whiteness-blackness plane in HWB-51

It can be seen that the partitioning doesn't occur in native whiteness-blackness space. Here's the relevant JavaScript pseudo-code:

var hwb_w = Math.min(linear_r, linear_g, linear_b);
var hwb_b = 1 - Math.max(linear_r, linear_g, linear_b);
var p = hwb_w + hwb_b;
var q = hwb_w / p;
if (p < 0.125) {
  return "vivid " + name;
}
if (p < 0.375) {
  return name;
}
if (p >= 0.875) {
  return achromatic(q);
}
...

Above, "p" is the Manhattan distance from the vivid corner; a measure of "achromicity". And "q" is a measure of how much of the "achromicity" is white, as opposed to black.

We compare this with the computation of HSV saturation and value parameters:

var hsv_v = Math.max(linear_r, linear_g, linear_b);
var chroma = hsv_v - Math.min(linear_r, linear_g, linear_b);
var hsv_s = (hsv_v > 0) ? (chroma / hsv_v) : 0;
...

We see that there are obvious similarities:

p == 1 - chroma
  == 1 - hsv_s * hsv_v

and 

q == (hsv_v - chroma) / (1 - chroma)
  == hsv_v * (1 - hsv_s) / (1 - hsv_s * hsv_v)

This shouldn't be a complete surprise as Smith and Lyons themselves noted that the "HWB model is very closely related to the HSV model". So we could quite simply reformulate the HWB-51 rules to use HSV or, indeed, HSL.

However, one of the reasons for the creation of HWB in 1995 was to have a "more intuitive hue-based color model" and I quite like the symmetry in the whiteness-blackness plane:

  • Adding whiteness creates a tint (baselightpale → white)
  • Adding blackness creates a shade (base → dark → deep → black)
  • Adding both creates a tone (base → dull → grey)
So describing the HWB-51 and HWB-91 colour naming schemes with reference to the HWB colour space may be useful to end users.

NOTE: Don't forget that HWB assumes that red, green and blue channels are linear. So sRGB values need linearizing, that is [and this was a new phrase for me] "inverse companding".

Colour Names 4

Even more colour naming experiments...

I added conversions for the ISCC-NBS System of Color Designation (1939 onwards) based on Paul Centore's centroids. I was unable to reproduce Paul's results, so I cannot fill in the seven blanks for out-of-sRGB-gamut points:

  • brilliant orange (4.5YR8.0/12.1)
  • vivid orange yellow (9.0YR7.2/16)
  • deep olive green (5.0GY2.0/8.0)
  • deep green (6.0G2.3/9.1)
  • deep bluish green (4.5BG2.3/9.0) and
  • deep greenish blue (4.5B2.5/9.0)

The "extrapolated" sRGB centroids could still be useful when searching for colour names but need to be computed from the original Munsell data points. This is a fiendish problem that I hope to re-visit if and when I implement a colour library in Egg.

To improve upon the ad hoc naming scheme of ISCC-NBS, the Color Naming Scheme (CNS) (1982) sought to systematize the name construction. CNS produces a palette of 627 colours, some of which have rather ambiguous names:

  • very dark vivid yellowish brown
  • very light grayish bluish purple

It does, however, encompass the majority of the eleven basic colour terms:

  1. white
  2. black
  3. red
  4. green
  5. yellow
  6. blue
  7. brown
  8. purple
  9. pink
  10. orange
  11. grey

All but "pink" are included, though "brown" is somewhat shoe-horned in.

As pointed out elsewhere, CNS doesn't seem to have a reference implementation, so it's very difficult to judge results. I've implemented a simple HSL centroid scheme pending further information.

Thinking about the basic colour terms (and grating against the use of terms like "chartreuse"), I implemented HWB-51 as a cut-down version of HWB-51 but just using the eleven basic terms plus the following adjectives:

  • deep
  • dark
  • light
  • pale
  • vivid
  • dull

This produces 77 combinations, but only 55 are used as names ("vivid black" is not meaningful):

black------
greydeep greydark greylight greypale grey--
white------
pink*--light pink*--dull pink
reddeep reddark redlight red*pale red*vivid reddull red
orangedeep orange*dark orange*light orangepale orangevivid orangedull orange
brown*-dark brown*---dull brown
yellowdeep yellowdark yellowlight yellowpale yellowvivid yellowdull yellow
greendeep greendark greenlight greenpale greenvivid greendull green
bluedeep bluedark bluelight bluepale bluevivid bluedull blue
purpledeep purpledark purplelight purplepale purplevivid purpledull purple

There are four pairs of synonyms:

  • "pink" = "light red"
  • "light pink" = "pale red"
  • "brown" = "dark orange"
  • "dark brown" = "deep orange"

This makes a total of 51 unique colours. Unfortunately, there's a large gap in the hue wheel between green and blue where cyan usually sits:

Hue ranges for HWB-51 names

Perhaps turquoise could be added.

The light/dark split for orange/brown and pink/red works quite well in HWB:

Approximate partitioning of whiteness-darkness plane for HWB-51 (orange/brown)

We could extend the idea to all sectors of the hue wheel:

  • red → pink/red
  • orange → orange/brown
  • yellow → yellow/olive
  • green → lime/green
  • blue → blue/navy
  • purple → violet/purple

However, now we're drifting away from using basic colour terms.

As an example of the various naming schemes, here are the results of looking up the web-safe colour "#FFCCFF":

X11Thistle9.5
RGB-125chantilly3.4
RGB-64mauve8.7
RGB-27orchid17.0
ISCC-NBSpurplish white0.1
CNSvery light strong purple1.4
HSL-79white-
HSV-79dull magenta-
HWB-51pale purple-
HWB-91pale magenta-

The final column is the ΔE*(2000) distance metric.

This is an extreme example because every name is different!