Implementação do CIEDE2000 em C

Esta página apresenta uma implementação de referência da fórmula de diferença de cor CIEDE2000 em C. Se quiser assegurar uma compatibilidade perfeita (até à décima casa decimal) com algumas implementações de terceiros, poderá ter de modificar os comentários no código fonte. Para facilitar isto, a seguinte ligação automatiza esta operação.

A função ΔE2000 em C

Consideremos a mais comum e académica (Sharma, 2005) das duas formulações.

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

#include <math.h>

// Expressly defining pi ensures that the code works on different platforms.
#ifndef M_PI
#define M_PI 3.14159265358979323846264338328
#endif

// 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.
static double ciede_2000(const double l_1, const double a_1, const double b_1, const double l_2, const double a_2, const double b_2) {
	// Working in C 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 double k_l = 1.0;
	const double k_c = 1.0;
	const double k_h = 1.0;
	double n = (sqrt(a_1 * a_1 + b_1 * b_1) + 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 - sqrt(n / (n + 6103515625.0)));
	// Application of the chroma correction factor.
	const double c_1 = sqrt(a_1 * a_1 * n * n + b_1 * b_1);
	const double c_2 = 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.
	double h_1 = atan2(b_1, a_1 * n);
	double h_2 = atan2(b_2, a_2 * n);
	h_1 += (h_1 < 0.0) * 2.0 * M_PI;
	h_2 += (h_2 < 0.0) * 2.0 * M_PI;
	n = fabs(h_2 - h_1);
	// Cross-implementation consistent rounding.
	if (M_PI - 1E-14 < n && n < M_PI + 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.
	double h_m = (h_1 + h_2) * 0.5;
	double h_d = (h_2 - h_1) * 0.5;
	h_d += (M_PI < n) * 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 < n) * M_PI;
	// h_m += (M_PI < n) * ((h_m < M_PI) - (M_PI <= h_m)) * M_PI;
	const double p = 36.0 * h_m - 55.0 * M_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.
	const double r_t = -2.0 * sqrt(n / (n + 6103515625.0))
			* sin(M_PI / 3.0 * exp(p * p / (-25.0 * M_PI * M_PI)));
	n = (l_1 + l_2) * 0.5;
	n = (n - 50.0) * (n - 50.0);
	// Lightness.
	const double l = (l_2 - l_1) / (k_l * (1.0 + 0.015 * n / sqrt(20.0 + n)));
	// These coefficients adjust the impact of different harmonic
	// components on the hue difference calculation.
	const double t = 1.0	+ 0.24 * sin(2.0 * h_m + M_PI / 2.0)
				+ 0.32 * sin(3.0 * h_m + 8.0 * M_PI / 15.0)
				- 0.17 * sin(h_m + M_PI / 3.0)
				- 0.20 * sin(4.0 * h_m + 3.0 * M_PI / 20.0);
	n = c_1 + c_2;
	// Hue.
	const double h = 2.0 * sqrt(c_1 * c_2) * sin(h_d) / (k_h * (1.0 + 0.0075 * n * t));
	// Chroma.
	const double 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 sqrt(l * l + h * h + c * c + c * h * r_t);
}

// Compilation is done using GCC or CLang :
// - gcc -std=c99 -Wall -Wextra -pedantic -Ofast -o ciede-2000-compiled ciede-2000.c -lm
// - clang -std=c99 -Wall -Wextra -pedantic -Ofast -o ciede-2000-compiled ciede-2000.c -lm

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

// L1 = 65.4   a1 = 32.8   b1 = -3.5
// L2 = 64.1   a2 = 26.8   b2 = 4.2
// CIE ΔE00 = 5.5643553151 (Bruce Lindbloom, Netflix’s VMAF, ...)
// CIE ΔE00 = 5.5643412178 (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.

Parâmetros k_l, k_c e k_h

Os parâmetros k_l, k_c e k_h na fórmula CIEDE2000 são factores de ponderação aplicados aos componentes de brilho (ΔL*), croma (ΔC*) e matiz (ΔH*), respetivamente. São definidos como constantes no código fonte. No código-fonte, são definidos como constantes com um valor por defeito de 1, que corresponde às condições de observação padrão estabelecidas pela Comissão Internacional da Iluminação (CIE). Na prática, pode ser necessário ajustar estes coeficientes para refletir condições específicas: por exemplo, k_l = 2 é por vezes utilizado para dar mais peso a diferenças de brilho (uma ocorrência comum na indústria têxtil), enquanto k_c ou k_h podem ser reduzidos para aumentar a tolerância a variações de saturação ou matiz, dependendo dos requisitos. Estes coeficientes variam normalmente entre 0,5 e 2.

Precisão e fiabilidade do código fonte

A diferença entre a formulação académica de Sharma e a formulação simplificada de Lindbloom não excede ±0,0003 no ΔE2000 final. Isto corresponde à diferença normalmente medida entre duas implementações de 32 bits e é impercetível ao olho humano. As nossas implementações de 64 bits, todas consistentes entre si, garantem pelo menos 10 casas decimais corretas, pelo que a escolha de uma formulação em detrimento de outra é um pormenor técnico. A fórmula predefinida nesta página é a mais frequentemente apresentada na comunidade, é ligeiramente mais fácil de vetorizar.

✎ Se verificar que os comentários no código-fonte não coincidem com os comentários em inglês, informe o autor da página para que tal possa ser corrigido.

Como é que se convertem cores RGB em L*a*b*?

Terá de utilizar o espaço de cor intermédio XYZ para a conversão e, se precisar de ajuda, o código fonte é fornecido no final desta página (utilizando o ponto branco D65 formalizado em 1964).

Intervalos de valores no CIELAB e interpretação do ΔE2000

No espaço de cor CIELAB, o componente L* representa a luminosidade e normalmente varia de 0 (preto) a 100 (branco). Os componentes a* e b* representam os eixos de cor: a* vai do verde ao vermelho, enquanto b* vai do azul ao amarelo. Na prática, os valores de a* e b* costumam estar entre -128 e +127, embora possam ultrapassar ligeiramente esses limites dependendo da conversão de cor.

ΔE2000 (CIEDE2000) mede a diferença perceptível entre duas cores: 0 significa cores idênticas, e valores maiores (até cerca de 185 em casos extremos) indicam uma diferença mais significativa. Por exemplo, um valor ΔE2000 em torno de 5 indica cores próximas, enquanto em torno de 15 indica cores claramente diferentes.

Exemplo de utilização em C

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

const double l_1 = 28.9, a_1 = 47.5, b_1 = 2.0;
const double l_2 = 28.8, a_2 = 41.6, b_2 = -1.7;

const double delta_e = ciede_2000(l_1, a_1, b_1, l_2, a_2, b_2);
printf("%.12f\n", delta_e);

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

Resultados dos testes

Esta função C foi testada com o driver Julia de precisão múltipla concebido para este fim.

CIEDE2000 Verification Summary :
  First Verified Line : 48,104,115.93,93,27,56.7,40.47788983936747087
             Duration : 18.26 s
            Successes : 10000000
               Errors : 0
      Average Delta E : 62.9586
    Average Deviation : 6.0772934018515914e-15
    Maximum Deviation : 2.4158453015843406e-13

Ficheiros para descarregar

Pode utilizar livremente estes ficheiros disponibilizados pelo Michel, mesmo para fins comerciais.

Comunidade

O que pensa deste código fonte ou do CIEDE2000? A sua opinião é importante para nós! O livro de visitas já contém 9 mensagens - incluindo 1 em português. Dê uma vista de olhos e partilhe a sua opinião.