Implementazione di CIEDE2000 in Lua

Questa pagina presenta un’implementazione di riferimento della formula della differenza di colore CIEDE2000 scritta nel linguaggio di programmazione Lua. Se si vuole garantire la perfetta compatibilità (con la decima cifra decimale) con alcune implementazioni di terze parti, potrebbe essere necessario modificare i commenti nel codice sorgente. Per facilitare questa operazione, il seguente link la automatizza.

La funzione ΔE2000 in Lua

Consideriamo la più comune e accademica (Sharma, 2005) delle due formulazioni.

-- This function written in Lua is not affiliated with the CIE (International Commission on Illumination),
-- and is released into the public domain. It is provided "as is" without any warranty, express or implied.

-- The classic CIE ΔE2000 implementation, which operates on two L*a*b* colors, and returns their difference.
-- "l" ranges from 0 to 100, while "a" and "b" are unbounded and commonly clamped to the range of -128 to 127.
function ciede_2000(l_1, a_1, b_1, l_2, a_2, b_2)
	-- Working in Lua/LuaJIT with the CIEDE2000 color-difference formula.
	-- k_l, k_c, k_h are parametric factors to be adjusted according to
	-- different viewing parameters such as textures, backgrounds...
	local k_l, k_c, k_h = 1.0, 1.0, 1.0;
	local n = (math.sqrt(a_1 * a_1 + b_1 * b_1) + math.sqrt(a_2 * a_2 + b_2 * b_2)) * 0.5;
	n = n * n * n * n * n * n * n;
	-- A factor involving chroma raised to the power of 7 designed to make
	-- the influence of chroma on the total color difference more accurate.
	n = 1.0 + 0.5 * (1.0 - math.sqrt(n / (n + 6103515625.0)));
	-- Simulate atan2, as Lua does not originally have this built-in.
	local c = a_1 * n;
	local c_1 = math.sqrt(c * c + b_1 * b_1);
	if 0.0 < a_1 then
		h_1 = math.atan(b_1 / c) + (b_1 < 0.0 and 2.0 or 0.0) * math.pi;
	elseif a_1 < 0.0 then
		h_1 = math.atan(b_1 / c) + math.pi;
	else
		h_1 = (b_1 < 0.0 and 1.5 or 0.0 < b_1 and 0.5 or 1.0) * math.pi;
	end
	c = a_2 * n;
	local c_2 = math.sqrt(c * c + b_2 * b_2);
	if 0.0 < a_2 then
		h_2 = math.atan(b_2 / c) + (b_2 < 0.0 and 2.0 or 0.0) * math.pi;
	elseif a_2 < 0.0 then
		h_2 = math.atan(b_2 / c) + math.pi;
	else
		h_2 = (b_2 < 0.0 and 1.5 or 0.0 < b_2 and 0.5 or 1.0) * math.pi;
	end
	-- The atan2 polyfill (customized) is complete.
	n = math.abs(h_2 - h_1);
	-- Cross-implementation consistent rounding.
	if math.pi - 1E-14 < n and n < math.pi + 1E-14 then n = math.pi end;
	-- When the hue angles lie in different quadrants, the straightforward
	-- average can produce a mean that incorrectly suggests a hue angle in
	-- the wrong quadrant, the next lines handle this issue.
	local h_m = (h_1 + h_2) * 0.5;
	local h_d = (h_2 - h_1) * 0.5;
	if math.pi < n then
		h_d = h_d + math.pi;
		-- 📜 Sharma’s formulation doesn’t use the next line, but the one after it,
		-- and these two variants differ by ±0.0003 on the final color differences.
		h_m = h_m + math.pi;
		-- h_m = h_m + (h_m < math.pi and math.pi or -math.pi)
	end
	local p = 36.0 * h_m - 55.0 * math.pi;
	n = (c_1 + c_2) * 0.5;
	n = n * n * n * n * n * n * n;
	-- The hue rotation correction term is designed to account for the
	-- non-linear behavior of hue differences in the blue region.
	local r_t = -2.0 * math.sqrt(n / (n + 6103515625.0)) *
			math.sin(math.pi / 3.0 * math.exp(p * p / (-25.0 * math.pi * math.pi)));
	n = (l_1 + l_2) * 0.5;
	n = (n - 50.0) * (n - 50.0);
	-- Lightness.
	local l = (l_2 - l_1) / (k_l * (1.0 + 0.015 * n / math.sqrt(20.0 + n)));
	-- These coefficients adjust the impact of different harmonic
	-- components on the hue difference calculation.
	local t = 1.0	+ 0.24 * math.sin(2.0 * h_m + math.pi * 0.5)
			+ 0.32 * math.sin(3.0 * h_m + 8.0 * math.pi / 15.0)
			- 0.17 * math.sin(h_m + math.pi / 3.0)
			- 0.20 * math.sin(4.0 * h_m + 3.0 * math.pi / 20.0);
	n = c_1 + c_2;
	-- Hue.
	local h = 2.0 * math.sqrt(c_1 * c_2) * math.sin(h_d) / (k_h * (1.0 + 0.0075 * n * t));
	-- Chroma.
	local c = (c_2 - c_1) / (k_c * (1.0 + 0.0225 * n));
	-- Returning the square root ensures that dE00 accurately reflects the
	-- geometric distance in color space, which can range from 0 to around 185.
	return math.sqrt(l * l + h * h + c * c + c * h * r_t);
end

-- GitHub Project : https://github.com/michel-leonard/ciede2000-color-matching
--   Online Tests : https://michel-leonard.github.io/ciede2000-color-matching

-- L1 = 42.5   a1 = 23.6   b1 = -4.4
-- L2 = 45.2   a2 = 18.5   b2 = 3.5
-- CIE ΔE00 = 6.4300403439 (Bruce Lindbloom, Netflix’s VMAF, ...)
-- CIE ΔE00 = 6.4300224381 (Gaurav Sharma, OpenJDK, ...)
-- Deviation between implementations ≈ 1.8e-5

-- See the source code comments for easy switching between these two widely used ΔE*00 implementation variants.

Parametri k_l, k_c e k_h

I parametri k_l, k_c e k_h nella formula CIEDE2000 sono fattori di ponderazione applicati rispettivamente alle componenti di luminosità (ΔL*), croma (ΔC*) e tinta (ΔH*). Sono definiti come costanti nel codice sorgente. Nel codice sorgente sono definiti come costanti con un valore predefinito di 1, che corrisponde alle condizioni di osservazione standard stabilite dalla Commissione internazionale per l’illuminazione (CIE). In pratica, potrebbe essere necessario regolare questi coefficienti per riflettere condizioni specifiche: ad esempio, k_l = 2 viene talvolta utilizzato per dare maggior peso alle differenze di luminosità (un caso comune nell’industria tessile), mentre k_c o k_h possono essere ridotti per aumentare la tolleranza alle variazioni di saturazione o di tonalità. In sintesi, questi coefficienti oscillano solitamente tra 0,5 e 2, dove 1 è il valore più comune.

Precisione e affidabilità del codice sorgente

La differenza tra la formulazione accademica di Sharma e quella semplificata di Lindbloom non supera ±0,0003 sul ΔE2000 finale. L’implementazione qui presentata è a 64 bit e garantisce una precisione superiore a 10 cifre decimali; la scelta di una formulazione piuttosto che un’altra è, quindi, un dettaglio tecnico. Nella parte superiore della pagina è possibile scegliere tra le due formulazioni; quella attualmente visualizzata è la formulazione semplificata.

Come si può stabilire se una determinata implementazione di CIEDE2000 è accademica o semplificata?

• Valutate ciede_2000(56.6, 43.6, 41.1, 68.4, 9.4, -8.6)
• Se il risultato è 30.0001, si tratta del tipo accademico (come Sharma, OpenJDK, ecc.)
• Se il risultato è 29.9999, si tratta del tipo semplificato (come Lindbloom, Netflix VMAF, ecc.)

Come si convertono i colori RGB in L*a*b*?

Per la conversione è necessario utilizzare lo spazio colore intermedio XYZ; se avete bisogno di aiuto, il codice sorgente è disponibile in fondo a questa pagina (utilizzando il punto di bianco D65 formalizzato nel 1964).

Intervalli di valori in CIELAB e interpretazione del ΔE2000

Nello spazio colore CIELAB, la componente L* rappresenta la luminosità e varia tipicamente da 0 (nero) a 100 (bianco). Le componenti a* e b* definiscono gli assi cromatici: a* va dal verde al rosso, mentre b* va dal blu al giallo. In pratica, i valori di a* e b* sono quasi sempre compresi in un intervallo compreso tra -128 e +127, sebbene lo standard non specifichi un limite ufficiale per queste due componenti.

ΔE2000 (CIEDE2000) misura la differenza percepita tra due colori: 0 significa colori identici, e valori più alti (fino a 185 e oltre) indicano una differenza più evidente. Per esempio, un ΔE2000 intorno a 5 indica colori vicini, mentre intorno a 15 indica colori chiaramente distinti. Quando il valore ΔE2000 supera 40, i colori confrontati non hanno praticamente più nulla in comune e non è più possibile ricavarne informazioni precise.

Esempio di utilizzo in Lua

-- Compute the Delta E (CIEDE2000) color difference between two L*a*b* colors in Lua

-- Color 1
local L1, a1, b1 = 75.1, 61.9, -3.2

-- Color 2
local L2, a2, b2 = 75.6, 55.9, 3.1

local deltaE = ciede_2000(L1, a1, b1, L2, a2, b2)
print(deltaE)

-- .................................................. This shows a ΔE2000 of 3.3591979531
-- As explained in the comments, compliance with Gaurav Sharma would display 3.3591841825

I risultati dei test

Il nostro programma di test, scritto in C99, comprende 250 test statici accurati. Questi test garantiscono che i calcoli vengano eseguiti senza errori, anche in casi limite critici, ad esempio quando la funzione arctangente restituisce un valore matematicamente indefinito. I risultati dimostrano che questa funzione CIEDE2000 in Lua è interoperabile con gli 41 altri linguaggi di programmazione che offriamo.

CIEDE2000 Verification Summary :
  First Verified Line : 25.3,0.28,53.78,65.8,-101.21,-86,67.92949263023695
             Duration : 19.28 s
            Successes : 10000000
               Errors : 0
      Average Delta E : 62.9474
    Average Deviation : 4.2586916049192067e-15
    Maximum Deviation : 1.1368683772161603e-13

File da scaricare

Sentitevi liberi di utilizzare questi file messi a disposizione da Michel, anche per scopi commerciali.

Comunità

Cosa ne pensate di questo codice sorgente o di CIEDE2000? La vostra opinione è importante per noi! Il libro degli ospiti contiene già 9 messaggi, di cui 1 in italiano. Date un’occhiata e condividete la vostra opinione.