Cannot convert 255 bit RGB to L*a*b*

[ReidWeb]

I'm trying to convert from 255 bit colour to the L*a*b* colour space.

From reviewing the docs, I see line

Integers in domain-range [0, 2**n -1] where n is the bit depth are scaled by 2**n -1.

Thus my understanding is that the below code should work?

a = np.array([103, 103, 103])
a_as_lab = colour.convert(a, 'sRGB', 'CIE Lab')
print(a_as_lab)

Yields result

[ 4.51622305e+01   3.01950285e-03   1.38126338e-03 ]

However according to color designer I would expect value lab(43.6, 0, 0). Converting through chrome dev tools yields value 43.6, 0.01, 0. nixsensor.com seems to give a better process where I can specify the Illuminant (using D65 10), which yields result 43.60 0.00 0.00. All three of these are in the same range.

Trying to understand what is causing this variance by several orders of magnitude,

• ahead of calling colour.convert(...) do I need to have converted do a domain range of 0-1? If so how?
• or am I missing a parameter to the convert function?
• or am I using the wrong value for source argument, do I need to use sRGB or Output-Referred RGB, or something else?

[ReidWeb]

I did some further testing with different values, it appears I need to do some transformation between Domain-Range-Scales?

I did this roughly as below

    b= np.asarray([113, 167, 138]) / 255.0
    
    b_as_lab = colour.convert(b,  'sRGB', 'CIE Lab') * 100.0

Which yields result

64.14724066 -24.18055994   9.39307697

which matches the expected value with my test methodology above: 64.15 -24.21 9.39.

(I understand this division and multiplication is definitely not the be best way to do this, seeking a better way)

However when I try this same code with the a as above, I get the wrong value

 [  4.36000737e+01   3.97073556e-03   1.81640220e-03]

I tested with other low magnitude values such as [1, 2, 3]; it yields the correct result, testing with another value where r, g, b are the same also yields an incorrect result.

[nick-shaw]

I suspect the problem is related to the fact that the sRGB standard defines the RGB to XYZ matrix to only four decimal places. When using this matrix, converting equal sRGB values to XYZ as a step on the way to L*a*b* will produce XYZ values which are not an exact multiple of D65 white. Thus zero a* and b* values will not be produced.

Setting the use_derived_matrix_RGB_to_XYZ attribute to True for the sRGB colour space should yield the expected result.

colour.models.RGB_COLOURSPACE_sRGB.use_derived_matrix_RGB_to_XYZ=True

[ReidWeb]

that works thank you!

Never mind it did not!

Applying this statement prior to my code,

colour.models.RGB_COLOURSPACE_sRGB.use_derived_matrix_RGB_to_XYZ=True

a = np.array([103, 103, 103]) /255
b = np.array([113, 167, 138]) /255

a_as_lab = colour.convert(a, 'sRGB', 'CIE Lab')  * 100

b_as_lab = colour.convert(b, 'sRGB',  'CIE Lab')  * 100

print(a_as_lab) # Expect  43.60 0.00 0.00
print(b_as_lab)  # Expect: 64.15 -24.21 9.39 

yields result

[  4.36000737e+01  -5.55111512e-14   0.00000000e+00]
[ 64.14662382 -24.18319038   9.39035373]

so not matching expected values

(Have tried removing multiplication, removing division and removing both.

[ReidWeb]

a = np.array([103, 103, 103]) 
b = np.array([113, 167, 138])  # MW Stone Age Green

a_as_lab = colour.convert(a, 'sRGB',  'CIE Lab')  

b_as_lab = colour.convert(b, 'sRGB',  'CIE Lab') 

print(a_as_lab) # Expect 43.60 0.00 0.00
print(b_as_lab)  # Expect: : 64.17 -24.55 9.49

yields

[ 45.16223054   0.           0.        ]
[ 62.8802731  -20.59803419   8.12193907]

which is at least a close value, assumably incurred due to rounding error or the higher precision of colour-science compared to online tools

[nick-shaw]

I have to admit, being a control freak I like to keep manual control of the steps, and not use the combined convert() function. If I do that I get:

>>> colour.models.RGB_COLOURSPACE_sRGB.use_derived_matrix_RGB_to_XYZ=True
>>> RGB = np.array([103, 103, 103])
>>> RGB_lin = colour.cctf_decoding(RGB/255, 'sRGB')
>>> M = colour.models.RGB_COLOURSPACE_sRGB.matrix_RGB_to_XYZ
>>> XYZ = colour.algebra.vector_dot(M, RGB_lin)
>>> colour.XYZ_to_Lab(XYZ)
array([ 43.60007373,   0.        ,   0.        ])

[ReidWeb]

Ah will try that!

[ReidWeb]

works a charm, thank you!