Implementazione di CIEDE2000 in Zig

Questa pagina presenta un’implementazione di riferimento della formula della differenza cromatica CIEDE2000 in Zig. Se si desidera ottenere una corrispondenza esatta con le implementazioni di terze parti fino a 10 cifre decimali, potrebbe essere necessario apportare alcune modifiche al codice sorgente, in particolare (de)commentando alcune righe, che possono essere applicate automaticamente tramite il link sottostante.

La funzione ΔE2000 in Zig

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

// This function written in Zig 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.

const std = @import("std");
const math = std.math;

// 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.
pub fn ciede_2000(l_1: f64, a_1: f64, b_1: f64, l_2: f64, a_2: f64, b_2: f64) f64 {
    // Working in Zig 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...
    const k_l = @as(f64, 1.0);
    const k_c = @as(f64, 1.0);
    const k_h = @as(f64, 1.0);
    // Expressly defining pi ensures that the code works on different platforms.
    const m_pi = @as(f64, 3.14159265358979323846264338327950288);
    var n = (math.sqrt(a_1 * a_1 + b_1 * b_1) + math.sqrt(a_2 * a_2 + b_2 * b_2)) * @as(f64, 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 = @as(f64, 1.0) + @as(f64, 0.5) * (@as(f64, 1.0) - math.sqrt(n / (n + @as(f64, 6103515625.0))));
    // Application of the chroma correction factor.
    const c_1 = math.sqrt(a_1 * a_1 * n * n + b_1 * b_1);
    const c_2 = math.sqrt(a_2 * a_2 * n * n + b_2 * b_2);
    // atan2 is preferred over atan because it accurately computes the angle of
    // a point (x, y) in all quadrants, handling the signs of both coordinates.
    var h_1 = math.atan2(b_1, a_1 * n);
    var h_2 = math.atan2(b_2, a_2 * n);
    if (h_1 < @as(f64, 0.0)) h_1 += @as(f64, 2.0) * m_pi;
    if (h_2 < @as(f64, 0.0)) h_2 += @as(f64, 2.0) * m_pi;
    if (h_2 < h_1) { n = h_1 - h_2; } else {  n = h_2 - h_1; }
    // Cross-implementation consistent rounding.
    if (m_pi - @as(f64, 1E-14) < n and n < m_pi + @as(f64, 1E-14)) n = m_pi;
    // 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.
    var h_m = (h_1 + h_2) * @as(f64, 0.5);
    var h_d = (h_2 - h_1) * @as(f64, 0.5);
    if (m_pi < n) {
        h_d += m_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 += m_pi;
        // if (h_m < m_pi) { h_m += m_pi; } else { h_m -= m_pi; }
    }
    const p = @as(f64, 36.0) * h_m - @as(f64, 55.0) * m_pi;
    n = (c_1 + c_2) * @as(f64, 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.
    const r_t = @as(f64, -2.0) * math.sqrt(n / (n + @as(f64, 6103515625.0)))
                  * math.sin(m_pi / @as(f64, 3.0) * math.exp(p * p / (@as(f64, -25.0) * m_pi * m_pi)));
    n = (l_1 + l_2) * @as(f64, 0.5);
    n = (n - @as(f64, 50.0)) * (n - @as(f64, 50.0));
    // Lightness.
    const l = (l_2 - l_1) / (k_l * (@as(f64, 1.0) + @as(f64, 0.015)
                * n / math.sqrt(@as(f64, 20.0) + n)));
    // These coefficients adjust the impact of different harmonic
    // components on the hue difference calculation.
    const t = @as(f64, 1.0)
                + @as(f64, 0.24) * math.sin(@as(f64, 2.0) * h_m + m_pi / @as(f64, 2.0))
                + @as(f64, 0.32) * math.sin(@as(f64, 3.0) * h_m + @as(f64, 8.0) * m_pi / @as(f64, 15.0))
                - @as(f64, 0.17) * math.sin(h_m + m_pi / @as(f64, 3.0))
                - @as(f64, 0.20) * math.sin(@as(f64, 4.0) * h_m + @as(f64, 3.0) * m_pi / @as(f64, 20.0));
    n = c_1 + c_2;
    // Hue.
    const h = @as(f64, 2.0) * math.sqrt(c_1 * c_2)
                * math.sin(h_d) / (k_h * (@as(f64, 1.0) + @as(f64, 0.0075) * n * t));
    // Chroma.
    const c = (c_2 - c_1) / (k_c * (@as(f64, 1.0) + @as(f64, 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);
}

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

// L1 = 18.9   a1 = 31.0   b1 = -3.8
// L2 = 20.9   a2 = 25.0   b2 = 4.5
// CIE ΔE00 = 6.0764044777 (Bruce Lindbloom, Netflix’s VMAF, ...)
// CIE ΔE00 = 6.0763907209 (Gaurav Sharma, OpenJDK, ...)
// Deviation between implementations ≈ 1.4e-5

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

Precisione e affidabilità del codice sorgente

La differenza tra le formulazioni di Sharma e Lindbloom non supera mai ±0,0003 sul ΔE2000 finale, il che corrisponde alla differenza abituale misurata tra due implementazioni a 32 bit ed è impercettibile a occhio umano. Le nostre implementazioni a 64 bit, tutte coerenti tra loro, garantiscono almeno 10 cifre decimali corrette, quindi la scelta di una formulazione rispetto a un’altra dipende principalmente dall’interoperabilità desiderata. La formulazione che appare di default in questa pagina è la più comunemente utilizzata (il suo micro-vantaggio è che si basa sulla comunità ed è più leggera del suo analogo quando viene vettorializzata).

✎ Se trovate un commento nel codice sorgente che non corrisponde a un’altra lingua, informate l’autore del sito, che studierà il vostro suggerimento e lo incorporerà nel codice sorgente.

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

Andate alla pagina AWK, C, Dart, Java, JavaScript, Kotlin, Lua, PHP, Python, Ruby o Rust dove tale convertitore (che utilizza l’illuminante D65) è già implementato in aggiunta alla funzione di confronto dei colori.

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* si collocano solitamente tra -128 e +127, anche se possono superare leggermente questi limiti in base alle conversioni cromatiche.

Parametri k_l, k_c e k_h

I parametri k_l, k_c e k_h sono fattori di ponderazione applicati ai termini di luminosità (ΔL*), croma (ΔC*) e tinta (ΔH*) nella formula CIEDE2000. Il loro valore predefinito è 1, che corrisponde alle condizioni di osservazione standard raccomandate dalla Commissione internazionale per l’illuminazione. In pratica, questi coefficienti vengono regolati per riflettere condizioni specifiche: ad esempio, k_l = 2 viene talvolta utilizzato per dare maggiore peso alle differenze di luminosità (comune nella stampa), mentre k_c o k_h possono essere ridotti per aumentare la tolleranza alle variazioni di saturazione o tinta a seconda delle esigenze del controllo qualità. A seconda del contesto, questi coefficienti variano tipicamente tra 0,5 e 2.

ΔE2000 (CIEDE2000) misura la differenza percepita tra due colori: 0 significa colori identici, e valori più alti (fino a circa 185 nei casi estremi) indicano una differenza più evidente. Per esempio, un ΔE2000 intorno a 5 indica colori vicini, mentre intorno a 15 indica colori chiaramente distinti.

Esempio di utilizzo in Zig

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

const l1, const a1, const b1 = .{ 52.9, 33.7, -2.0 };
const l2, const a2, const b2 = .{ 53.5, 28.5, 1.9 };

const delta_e = ciede_2000(l1, a1, b1, l2, a2, b2);
std.debug.print("{}\n", .{delta_e});

// .................................................. This shows a ΔE2000 of 3.2925558212
// As explained in the comments, compliance with Gaurav Sharma would display 3.2925418295

I risultati dei test

Il driver scritto in linguaggio C99, con 250 test statici precisi, ha dimostrato che questa funzione Zig è interoperabile con la funzione CIEDE2000 disponibile in altri linguaggi di programmazione.

CIEDE2000 Verification Summary :
  First Verified Line : 77,50.44,-119,52,-98,77,71.16185568944698
             Duration : 8.25 s
            Successes : 10000000
               Errors : 0
      Average Delta E : 63.2426
    Average Deviation : 4.0e-15
    Maximum Deviation : 2.6e-13

File da scaricare

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

Comunità

Se volete lasciare la vostra opinione su questo codice sorgente Zig o sul CIEDE2000 in generale, il libro degli ospiti contiene già 1 messaggi in italiano e 9 messaggi in totale, quindi fateci sapere cosa ne pensate.