CIELAB color space

[Leterax]

Have you thought of using the CIELAB color space instead of HSV/RGB? I have had pretty good success using this, but have only implemented it in golang, not python. The LAB colorspace has the advantage of being perceptually uniform.

[Leterax]

Here is some code to convert RGB to LAB:

func Rgb2lab(color RGB) LAB {
	return xyz2lab(rgb2xyz(color))
}

// rgb2xyz converts from the RGB to the XYZ colorspace
func rgb2xyz(color RGB) XYZ {
	r := float32(color.R) / 255.
	g := float32(color.G) / 255.
	b := float32(color.B) / 255.

	if r > 0.04045 {
		r = math32.Pow((r+0.055)/1.055, 2.4)
	} else {
		r = r / 12.92
	}

	if g > 0.04045 {
		g = math32.Pow((g+0.055)/1.055, 2.4)
	} else {
		g = g / 12.92
	}

	if b > 0.04045 {
		b = math32.Pow((b+0.055)/1.055, 2.4)
	} else {
		b = b / 12.92
	}

	r = r * 100
	g = g * 100
	b = b * 100

	X := r*0.4124 + g*0.3576 + b*0.1805
	Y := r*0.2126 + g*0.7152 + b*0.0722
	Z := r*0.0193 + g*0.1192 + b*0.9505

	return XYZ{X, Y, Z}
}

// xyz2lab converts from the XYZ to the LAB colorspace
func xyz2lab(color XYZ) LAB {
	x := color.X / 94.811
	y := color.Y / 100.000
	z := color.Z / 107.304

	if x > 0.00885 {
		x = math32.Pow(x, 1./3.)
	} else {
		x = (7.787 * x) + (16. / 116.)
	}

	if y > 0.00885 {
		y = math32.Pow(y, 1./3.)
	} else {
		y = (7.787 * y) + (16. / 116.)
	}

	if z > 0.00885 {
		z = math32.Pow(z, 1./3.)
	} else {
		z = (7.787 * z) + (16. / 116.)
	}

	L := (116. * y) - 16.
	a := 500. * (x - y)
	b := 200. * (y - z)

	return LAB{L, a, b}
}

And two different distance functions:

// DeltaE76 calculates the simpler DeltaE76 between two LAB colors
func DeltaE76(colorA, colorB LAB) float32 {
	return math32.Sqrt(math32.Pow(colorB.L-colorA.L, 2.) + math32.Pow(colorB.A-colorA.A, 2.) + math32.Pow(colorB.B-colorA.B, 2.))
}

// DeltaE calculates the DeltaE between two LAB colors
func DeltaE(colorA LAB, colorB LAB) float32 {
	xC1 := math32.Sqrt(math32.Pow(colorA.A, 2) + math32.Pow(colorA.B, 2))
	xC2 := math32.Sqrt(math32.Pow(colorB.A, 2) + math32.Pow(colorB.B, 2))
	xDL := colorB.L - colorA.L
	xDC := xC2 - xC1

	xDE := math32.Sqrt(((colorA.L - colorB.L) * (colorA.L - colorB.L)) + ((colorA.A - colorB.A) * (colorA.A - colorB.A)) + ((colorA.B - colorB.B) * (colorA.B - colorB.B)))

	xDH := (xDE * xDE) - (xDL * xDL) - (xDC * xDC)

	if xDH > 0 {
		xDH = math32.Sqrt(xDH)
	} else {
		xDH = 0
	}
	xSC := 1 + (0.045 * xC1)
	xSH := 1 + (0.015 * xC1)

	xDC /= xSC
	xDH /= xSH

	dE := math32.Sqrt(math32.Pow(xDL, 2) + math32.Pow(xDC, 2) + math32.Pow(xDH, 2))
	return dE
}

[qTipTip]

Hello @Leterax !

Thanks a lot for chiming in! I'll look at this. The CIELAB color space is new to me!