What does Colour-Vision Deficiency and Discriminability conclude, in numbers, about “Safe Colours for Right and Wrong Buttons: a Hue Search and a Luminance-Only Scheme”?

Answer: Chapter 5 searches safe colours for right and wrong buttons: one dark and one light, one with a white and one with a black label, 3.01 apart in luminance, still differ by 21.85 under the deutan simulation.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (21 programs), classical sources and the author's hypotheses.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 21.85, 3.01

dark reds 237, light greens 715, pairs >= 3:1 apart 113064
chosen: #660000 (white label) and #338833 (black label)
label CR 13.42 and 4.71, buttons apart 3.01:1
viewdE00
normal62.10
protan32.91
deutan21.85
tritan56.30
grey25.28
Show the full program
# Chapter 5. p52: a pair that differs by luminance alone.
# Model: 'wrong' is dark with a white label (>= 4.5:1), 'right' is light
# with a black label (>= 4.5:1), and the two buttons are >= 3:1 apart in
# WCAG luminance, so they differ even with no hue at all. Among such
# pairs on a 16-level grid, pick the one nearest #D32F2F and #2E7D32.
import math


def lin(c):
    v = c / 255.0
    if v <= 0.04045:
        return v / 12.92
    return ((v + 0.055) / 1.055) ** 2.4


def rgb(h):
    h = h.lstrip("#")
    return tuple(lin(int(h[i:i + 2], 16)) for i in (0, 2, 4))


def lum(c):
    return math.fsum((0.2126 * c[0], 0.7152 * c[1], 0.0722 * c[2]))


def contrast(a, b):
    hi, lo = sorted((lum(a), lum(b)), reverse=True)
    return (hi + 0.05) / (lo + 0.05)

# Machado, Oliveira and Fernandes 2009, Table 1, severity 1.0 (rows).
MACHADO = {
    "protan": ((0.152286, 1.052583, -0.204868),
               (0.114503, 0.786281, 0.099216),
               (-0.003882, -0.048116, 1.051998)),
    "deutan": ((0.367322, 0.860646, -0.227968),
               (0.280085, 0.672501, 0.047413),
               (-0.011820, 0.042940, 0.968881)),
    "tritan": ((1.255528, -0.076749, -0.178779),
               (-0.078411, 0.930809, 0.147602),
               (0.004733, 0.691367, 0.303900)),
}


def sim(c, kind):
    # applied to linear sRGB, then clipped to the display range
    if kind == "normal":
        return tuple(c)
    out = []
    for row in MACHADO[kind]:
        v = math.fsum(m * x for m, x in zip(row, c))
        out.append(min(1.0, max(0.0, v)))
    return tuple(out)

SRGB_XYZ = ((0.4124, 0.3576, 0.1805),
            (0.2126, 0.7152, 0.0722),
            (0.0193, 0.1192, 0.9505))


def xyz(c):
    return tuple(math.fsum(m * x for m, x in zip(row, c))
                 for row in SRGB_XYZ)


WHITE = xyz((1.0, 1.0, 1.0))


def _f(t):
    d = 6.0 / 29.0
    if t > d ** 3:
        return t ** (1.0 / 3.0)
    return t / (3.0 * d * d) + 4.0 / 29.0


def lab(c):
    fx, fy, fz = (_f(v / w) for v, w in zip(xyz(c), WHITE))
    return (116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz))


def de00(p, q):
    # CIEDE2000 with kL = kC = kH = 1 (Sharma, Wu and Dalal 2005)
    l1, a1, b1 = p
    l2, a2, b2 = q
    cm = (math.hypot(a1, b1) + math.hypot(a2, b2)) / 2.0
    g = 0.5 * (1.0 - math.sqrt(cm ** 7 / (cm ** 7 + 25.0 ** 7)))
    a1p, a2p = (1.0 + g) * a1, (1.0 + g) * a2
    c1p, c2p = math.hypot(a1p, b1), math.hypot(a2p, b2)
    h1p = math.degrees(math.atan2(b1, a1p)) % 360.0 if c1p else 0.0
    h2p = math.degrees(math.atan2(b2, a2p)) % 360.0 if c2p else 0.0
    dl, dc = l2 - l1, c2p - c1p
    if c1p * c2p == 0.0:
        dhp = 0.0
    else:
        dhp = h2p - h1p
        if dhp > 180.0:
            dhp -= 360.0
        elif dhp < -180.0:
            dhp += 360.0
    dh = 2.0 * math.sqrt(c1p * c2p) * math.sin(math.radians(dhp / 2.0))
    lm, cmp_ = (l1 + l2) / 2.0, (c1p + c2p) / 2.0
    if c1p * c2p == 0.0:
        hm = h1p + h2p
    elif abs(h1p - h2p) <= 180.0:
        hm = (h1p + h2p) / 2.0
    elif h1p + h2p < 360.0:
        hm = (h1p + h2p + 360.0) / 2.0
    else:
        hm = (h1p + h2p - 360.0) / 2.0
    r = math.radians
    t = math.fsum((1.0, -0.17 * math.cos(r(hm - 30.0)),
                   0.24 * math.cos(r(2.0 * hm)),
                   0.32 * math.cos(r(3.0 * hm + 6.0)),
                   -0.20 * math.cos(r(4.0 * hm - 63.0))))
    dtheta = 30.0 * math.exp(-((hm - 275.0) / 25.0) ** 2)
    rc = 2.0 * math.sqrt(cmp_ ** 7 / (cmp_ ** 7 + 25.0 ** 7))
    sl = 1.0 + 0.015 * (lm - 50.0) ** 2 / math.sqrt(20.0 + (lm - 50.0) ** 2)
    sc = 1.0 + 0.045 * cmp_
    sh = 1.0 + 0.015 * cmp_ * t
    rt = -math.sin(2.0 * r(dtheta)) * rc
    x, y, z = dl / sl, dc / sc, dh / sh
    return math.sqrt(math.fsum((x * x, y * y, z * z, rt * y * z)))


def de76(p, q):
    return math.sqrt(math.fsum((u - v) ** 2 for u, v in zip(p, q)))


def hsv_code(h, s, v):
    # HSV (degrees, 0-1, 0-1) to 8-bit sRGB codes
    c = v * s
    hp = (h % 360.0) / 60.0
    x = c * (1.0 - abs(hp % 2.0 - 1.0))
    r, g, b = ((c, x, 0.0), (x, c, 0.0), (0.0, c, x),
               (0.0, x, c), (x, 0.0, c), (c, 0.0, x))[int(hp) % 6]
    m = v - c
    return tuple(int(round((u + m) * 255.0)) for u in (r, g, b))


def hexs(codes):
    return "#{:02X}{:02X}{:02X}".format(*codes)


def hue(c):
    r, g, b = (u / 255.0 for u in c)
    mx, mn = max(r, g, b), min(r, g, b)
    if mx == mn:
        return -1.0
    d = mx - mn
    if mx == r:
        h = ((g - b) / d) % 6.0
    elif mx == g:
        h = (b - r) / d + 2.0
    else:
        h = (r - g) / d + 4.0
    return 60.0 * h

W, K = (1.0, 1.0, 1.0), (0.0, 0.0, 0.0)
STEP = tuple(range(0, 256, 17))
VIEWS = ("normal", "protan", "deutan", "tritan")


def grey(c):
    y = lum(c)
    return (y, y, y)


if __name__ == "__main__":
    allc = [(r, g, b) for r in STEP for g in STEP for b in STEP]
    lc = {c: tuple(lin(u) for u in c) for c in allc}
    t1, t2 = lab(rgb("D32F2F")), lab(rgb("2E7D32"))
    dark = [c for c in allc if contrast(lc[c], W) >= 4.5
            and (0.0 <= hue(c) <= 30.0 or hue(c) >= 345.0)]
    light = [c for c in allc if contrast(lc[c], K) >= 4.5
             and 90 <= hue(c) <= 160]
    best = None
    count = 0
    for a in dark:
        for b in light:
            if contrast(lc[a], lc[b]) < 3.0:
                continue
            count += 1
            score = de00(lab(lc[a]), t1) + de00(lab(lc[b]), t2)
            if best is None or score < best[0]:
                best = (score, a, b)
    _, a, b = best
    print("dark reds {}, light greens {}, pairs >= 3:1 apart {}".format(
        len(dark), len(light), count))
    print("chosen: {} (white label) and {} (black label)".format(
        hexs(a), hexs(b)))
    print("label CR {:.2f} and {:.2f}, buttons apart {:.2f}:1".format(
        contrast(lc[a], W), contrast(lc[b], K),
        contrast(lc[a], lc[b])))
    print("view     dE00")
    for k in VIEWS:
        print("{:<7s}  {:5.2f}".format(
            k, de00(lab(sim(lc[a], k)), lab(sim(lc[b], k)))))
    print("grey     {:5.2f}".format(de00(lab(grey(lc[a])),
                                         lab(grey(lc[b])))))

Single source and citation

Fan, Y. (2026). Simulating Colour-Vision Deficiency and Colour Discriminability: Buttons and Charts as Seen by Red-Green Colour-Deficient Users (Version 1.0.0), Chapter 5: Safe Colours for Right and Wrong Buttons: a Hue Search and a Luminance-Only Scheme. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-324 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026324,
  author    = {Fan, Yafu},
  title     = {Simulating Colour-Vision Deficiency and Colour Discriminability: Buttons and Charts as Seen by Red-Green Colour-Deficient Users},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book