python-colormath

python-colormath is a simple Python module that spares the user from directly dealing with color math. Some features include:

  • Support for a wide range of color spaces. A good chunk of the CIE spaces, RGB, HSL/HSV, CMY/CMYK, and many more.
  • Conversions between the various color spaces. For example, XYZ to sRGB, Spectral to XYZ, CIE Lab to Adobe RGB.
  • Calculation of color difference. All CIE Delta E functions, plus CMC.
  • Chromatic adaptations (changing illuminants).
  • RGB to hex and vice-versa.
  • 16-bit RGB support.
  • Runs on Python 2.7 and Python 3.3+.

License: python-colormath is licensed under the BSD License.

Assorted Info

Topics

Installation

python-colormath currently requires Python 2.7 or Python 3.3+. There are no plans to add support for earlier versions of Python 2 or 3. The only other requirements are NumPy and networkx.

For those on Linux/Unix Mac OS, the easiest route will be pip or easy_install:

pip install colormath

If you are on Windows, you’ll need to visit NumPy, download their binary distribution, then install colormath.

Color Objects

python-colormath has support for many of the commonly used color spaces. These are represented by Color objects.

SpectralColor

class colormath.color_objects.SpectralColor(spec_340nm=0.0, spec_350nm=0.0, spec_360nm=0.0, spec_370nm=0.0, spec_380nm=0.0, spec_390nm=0.0, spec_400nm=0.0, spec_410nm=0.0, spec_420nm=0.0, spec_430nm=0.0, spec_440nm=0.0, spec_450nm=0.0, spec_460nm=0.0, spec_470nm=0.0, spec_480nm=0.0, spec_490nm=0.0, spec_500nm=0.0, spec_510nm=0.0, spec_520nm=0.0, spec_530nm=0.0, spec_540nm=0.0, spec_550nm=0.0, spec_560nm=0.0, spec_570nm=0.0, spec_580nm=0.0, spec_590nm=0.0, spec_600nm=0.0, spec_610nm=0.0, spec_620nm=0.0, spec_630nm=0.0, spec_640nm=0.0, spec_650nm=0.0, spec_660nm=0.0, spec_670nm=0.0, spec_680nm=0.0, spec_690nm=0.0, spec_700nm=0.0, spec_710nm=0.0, spec_720nm=0.0, spec_730nm=0.0, spec_740nm=0.0, spec_750nm=0.0, spec_760nm=0.0, spec_770nm=0.0, spec_780nm=0.0, spec_790nm=0.0, spec_800nm=0.0, spec_810nm=0.0, spec_820nm=0.0, spec_830nm=0.0, observer='2', illuminant='d50')[source]

Bases: colormath.color_objects.IlluminantMixin, colormath.color_objects.ColorBase

A SpectralColor represents a spectral power distribution, as read by a spectrophotometer. Our current implementation has wavelength intervals of 10nm, starting at 340nm and ending at 830nm.

Spectral colors are the lowest level, most “raw” measurement of color. You may convert spectral colors to any other color space, but you can’t convert any other color space back to spectral.

See Spectral power distribution on Wikipedia for some higher level details on how these work.

Parameters:
calc_density(density_standard=None)[source]

Calculates the density of the SpectralColor. By default, Status T density is used, and the correct density distribution (Red, Green, or Blue) is chosen by comparing the Red, Green, and Blue components of the spectral sample (the values being red in via “filters”).

get_illuminant_xyz(observer=None, illuminant=None)
Parameters:
  • observer (str) – Get the XYZ values for another observer angle. Must be either ‘2’ or ‘10’.
  • illuminant (str) – Get the XYZ values for another illuminant.
Returns:

the color’s illuminant’s XYZ values.

get_numpy_array()[source]

Dump this color into NumPy array.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

set_illuminant(illuminant)

Validates and sets the color’s illuminant.

Note

This only changes the illuminant. It does no conversion of the color’s coordinates. For this, you’ll want to refer to XYZColor.apply_adaptation.

Tip

Call this after setting your observer.

Parameters:illuminant (str) – One of the various illuminants.
set_observer(observer)

Validates and sets the color’s observer angle.

Note

This only changes the observer angle value. It does no conversion of the color’s coordinates.

Parameters:observer (str) – One of ‘2’ or ‘10’.
illuminant = None

The color’s illuminant. Set with set_illuminant().

observer = None

The color’s observer angle. Set with set_observer().

LabColor

class colormath.color_objects.LabColor(lab_l, lab_a, lab_b, observer='2', illuminant='d50')[source]

Bases: colormath.color_objects.IlluminantMixin, colormath.color_objects.ColorBase

Represents a CIE Lab color. For more information on CIE Lab, see Lab color space on Wikipedia.

Parameters:
get_illuminant_xyz(observer=None, illuminant=None)
Parameters:
  • observer (str) – Get the XYZ values for another observer angle. Must be either ‘2’ or ‘10’.
  • illuminant (str) – Get the XYZ values for another illuminant.
Returns:

the color’s illuminant’s XYZ values.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

set_illuminant(illuminant)

Validates and sets the color’s illuminant.

Note

This only changes the illuminant. It does no conversion of the color’s coordinates. For this, you’ll want to refer to XYZColor.apply_adaptation.

Tip

Call this after setting your observer.

Parameters:illuminant (str) – One of the various illuminants.
set_observer(observer)

Validates and sets the color’s observer angle.

Note

This only changes the observer angle value. It does no conversion of the color’s coordinates.

Parameters:observer (str) – One of ‘2’ or ‘10’.
illuminant = None

The color’s illuminant. Set with set_illuminant().

lab_a = None

a coordinate

lab_b = None

b coordinate

lab_l = None

L coordinate

observer = None

The color’s observer angle. Set with set_observer().

LCHabColor

class colormath.color_objects.LCHabColor(lch_l, lch_c, lch_h, observer='2', illuminant='d50')[source]

Bases: colormath.color_objects.IlluminantMixin, colormath.color_objects.ColorBase

Represents an CIE LCH color that was converted to LCH by passing through CIE Lab. This differs from LCHuvColor, which was converted to LCH through CIE Luv.

See Introduction to Colour Spaces by Phil Cruse for an illustration of how CIE LCH differs from CIE Lab.

Parameters:
get_illuminant_xyz(observer=None, illuminant=None)
Parameters:
  • observer (str) – Get the XYZ values for another observer angle. Must be either ‘2’ or ‘10’.
  • illuminant (str) – Get the XYZ values for another illuminant.
Returns:

the color’s illuminant’s XYZ values.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

set_illuminant(illuminant)

Validates and sets the color’s illuminant.

Note

This only changes the illuminant. It does no conversion of the color’s coordinates. For this, you’ll want to refer to XYZColor.apply_adaptation.

Tip

Call this after setting your observer.

Parameters:illuminant (str) – One of the various illuminants.
set_observer(observer)

Validates and sets the color’s observer angle.

Note

This only changes the observer angle value. It does no conversion of the color’s coordinates.

Parameters:observer (str) – One of ‘2’ or ‘10’.
illuminant = None

The color’s illuminant. Set with set_illuminant().

lch_c = None

C coordinate

lch_h = None

H coordinate

lch_l = None

L coordinate

observer = None

The color’s observer angle. Set with set_observer().

LCHuvColor

class colormath.color_objects.LCHuvColor(lch_l, lch_c, lch_h, observer='2', illuminant='d50')[source]

Bases: colormath.color_objects.IlluminantMixin, colormath.color_objects.ColorBase

Represents an CIE LCH color that was converted to LCH by passing through CIE Luv. This differs from LCHabColor, which was converted to LCH through CIE Lab.

See Introduction to Colour Spaces by Phil Cruse for an illustration of how CIE LCH differs from CIE Lab.

Parameters:
get_illuminant_xyz(observer=None, illuminant=None)
Parameters:
  • observer (str) – Get the XYZ values for another observer angle. Must be either ‘2’ or ‘10’.
  • illuminant (str) – Get the XYZ values for another illuminant.
Returns:

the color’s illuminant’s XYZ values.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

set_illuminant(illuminant)

Validates and sets the color’s illuminant.

Note

This only changes the illuminant. It does no conversion of the color’s coordinates. For this, you’ll want to refer to XYZColor.apply_adaptation.

Tip

Call this after setting your observer.

Parameters:illuminant (str) – One of the various illuminants.
set_observer(observer)

Validates and sets the color’s observer angle.

Note

This only changes the observer angle value. It does no conversion of the color’s coordinates.

Parameters:observer (str) – One of ‘2’ or ‘10’.
illuminant = None

The color’s illuminant. Set with set_illuminant().

lch_c = None

C coordinate

lch_h = None

H coordinate

lch_l = None

L coordinate

observer = None

The color’s observer angle. Set with set_observer().

LuvColor

class colormath.color_objects.LuvColor(luv_l, luv_u, luv_v, observer='2', illuminant='d50')[source]

Bases: colormath.color_objects.IlluminantMixin, colormath.color_objects.ColorBase

Represents an Luv color.

Parameters:
get_illuminant_xyz(observer=None, illuminant=None)
Parameters:
  • observer (str) – Get the XYZ values for another observer angle. Must be either ‘2’ or ‘10’.
  • illuminant (str) – Get the XYZ values for another illuminant.
Returns:

the color’s illuminant’s XYZ values.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

set_illuminant(illuminant)

Validates and sets the color’s illuminant.

Note

This only changes the illuminant. It does no conversion of the color’s coordinates. For this, you’ll want to refer to XYZColor.apply_adaptation.

Tip

Call this after setting your observer.

Parameters:illuminant (str) – One of the various illuminants.
set_observer(observer)

Validates and sets the color’s observer angle.

Note

This only changes the observer angle value. It does no conversion of the color’s coordinates.

Parameters:observer (str) – One of ‘2’ or ‘10’.
illuminant = None

The color’s illuminant. Set with set_illuminant().

luv_l = None

L coordinate

luv_u = None

u coordinate

luv_v = None

v coordinate

observer = None

The color’s observer angle. Set with set_observer().

XYZColor

class colormath.color_objects.XYZColor(xyz_x, xyz_y, xyz_z, observer='2', illuminant='d50')[source]

Bases: colormath.color_objects.IlluminantMixin, colormath.color_objects.ColorBase

Represents an XYZ color.

Parameters:
apply_adaptation(target_illuminant, adaptation='bradford')[source]

This applies an adaptation matrix to change the XYZ color’s illuminant. You’ll most likely only need this during RGB conversions.

get_illuminant_xyz(observer=None, illuminant=None)
Parameters:
  • observer (str) – Get the XYZ values for another observer angle. Must be either ‘2’ or ‘10’.
  • illuminant (str) – Get the XYZ values for another illuminant.
Returns:

the color’s illuminant’s XYZ values.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

set_illuminant(illuminant)

Validates and sets the color’s illuminant.

Note

This only changes the illuminant. It does no conversion of the color’s coordinates. For this, you’ll want to refer to XYZColor.apply_adaptation.

Tip

Call this after setting your observer.

Parameters:illuminant (str) – One of the various illuminants.
set_observer(observer)

Validates and sets the color’s observer angle.

Note

This only changes the observer angle value. It does no conversion of the color’s coordinates.

Parameters:observer (str) – One of ‘2’ or ‘10’.
illuminant = None

The color’s illuminant. Set with set_illuminant().

observer = None

The color’s observer angle. Set with set_observer().

xyz_x = None

X coordinate

xyz_y = None

Y coordinate

xyz_z = None

Z coordinate

xyYColor

class colormath.color_objects.xyYColor(xyy_x, xyy_y, xyy_Y, observer='2', illuminant='d50')[source]

Bases: colormath.color_objects.IlluminantMixin, colormath.color_objects.ColorBase

Represents an xyY color.

Parameters:
get_illuminant_xyz(observer=None, illuminant=None)
Parameters:
  • observer (str) – Get the XYZ values for another observer angle. Must be either ‘2’ or ‘10’.
  • illuminant (str) – Get the XYZ values for another illuminant.
Returns:

the color’s illuminant’s XYZ values.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

set_illuminant(illuminant)

Validates and sets the color’s illuminant.

Note

This only changes the illuminant. It does no conversion of the color’s coordinates. For this, you’ll want to refer to XYZColor.apply_adaptation.

Tip

Call this after setting your observer.

Parameters:illuminant (str) – One of the various illuminants.
set_observer(observer)

Validates and sets the color’s observer angle.

Note

This only changes the observer angle value. It does no conversion of the color’s coordinates.

Parameters:observer (str) – One of ‘2’ or ‘10’.
illuminant = None

The color’s illuminant. Set with set_illuminant().

observer = None

The color’s observer angle. Set with set_observer().

xyy_Y = None

Y coordinate

xyy_x = None

x coordinate

xyy_y = None

y coordinate

sRGBColor

class colormath.color_objects.sRGBColor(rgb_r, rgb_g, rgb_b, is_upscaled=False)[source]

Bases: colormath.color_objects.BaseRGBColor

Represents an sRGB color.

Note

If you pass in upscaled values, we automatically scale them down to 0.0-1.0. If you need the old upscaled values, you can retrieve them with get_upscaled_value_tuple().

Variables:
  • rgb_r (float) – R coordinate
  • rgb_g (float) – G coordinate
  • rgb_b (float) – B coordinate
  • is_upscaled (bool) – If True, RGB values are between 1-255. If False, 0.0-1.0.
Parameters:
  • rgb_r (float) – R coordinate. 0…1. 1-255 if is_upscaled=True.
  • rgb_g (float) – G coordinate. 0…1. 1-255 if is_upscaled=True.
  • rgb_b (float) – B coordinate. 0…1. 1-255 if is_upscaled=True.
  • is_upscaled (bool) – If False, RGB coordinate values are beteween 0.0 and 1.0. If True, RGB values are between 1 and 255.
get_rgb_hex()

Converts the RGB value to a hex value in the form of: #RRGGBB

Return type:str
get_upscaled_value_tuple()

Scales an RGB color object from decimal 0.0-1.0 to int 0-255.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

classmethod new_from_rgb_hex(hex_str)

Converts an RGB hex string like #RRGGBB and assigns the values to this sRGBColor object.

Return type:sRGBColor
clamped_rgb_b

The clamped (0.0-1.0) B value.

clamped_rgb_g

The clamped (0.0-1.0) G value.

clamped_rgb_r

The clamped (0.0-1.0) R value.

native_illuminant = 'd65'

The RGB space’s native illuminant. Important when converting to XYZ.

rgb_gamma = 2.2

RGB space’s gamma constant.

BT2020Color

class colormath.color_objects.BT2020Color(rgb_r, rgb_g, rgb_b, is_upscaled=False)[source]

Bases: colormath.color_objects.BaseRGBColor

Represents a ITU-R BT.2020 color.

Note

If you pass in upscaled values, we automatically scale them down to 0.0-1.0. If you need the old upscaled values, you can retrieve them with get_upscaled_value_tuple().

Variables:
  • rgb_r (float) – R coordinate
  • rgb_g (float) – G coordinate
  • rgb_b (float) – B coordinate
  • is_upscaled (bool) – If True, RGB values are between 1-255. If False, 0.0-1.0.
Parameters:
  • rgb_r (float) – R coordinate. 0…1. 1-255 if is_upscaled=True.
  • rgb_g (float) – G coordinate. 0…1. 1-255 if is_upscaled=True.
  • rgb_b (float) – B coordinate. 0…1. 1-255 if is_upscaled=True.
  • is_upscaled (bool) – If False, RGB coordinate values are beteween 0.0 and 1.0. If True, RGB values are between 1 and 255.
get_rgb_hex()

Converts the RGB value to a hex value in the form of: #RRGGBB

Return type:str
get_upscaled_value_tuple()

Scales an RGB color object from decimal 0.0-1.0 to int 0-255.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

classmethod new_from_rgb_hex(hex_str)

Converts an RGB hex string like #RRGGBB and assigns the values to this sRGBColor object.

Return type:sRGBColor
clamped_rgb_b

The clamped (0.0-1.0) B value.

clamped_rgb_g

The clamped (0.0-1.0) G value.

clamped_rgb_r

The clamped (0.0-1.0) R value.

native_illuminant = 'd65'

The RGB space’s native illuminant. Important when converting to XYZ.

rgb_gamma = 2.4

RGB space’s gamma constant.

AdobeRGBColor

class colormath.color_objects.AdobeRGBColor(rgb_r, rgb_g, rgb_b, is_upscaled=False)[source]

Bases: colormath.color_objects.BaseRGBColor

Represents an Adobe RGB color.

Note

If you pass in upscaled values, we automatically scale them down to 0.0-1.0. If you need the old upscaled values, you can retrieve them with get_upscaled_value_tuple().

Variables:
  • rgb_r (float) – R coordinate
  • rgb_g (float) – G coordinate
  • rgb_b (float) – B coordinate
  • is_upscaled (bool) – If True, RGB values are between 1-255. If False, 0.0-1.0.
Parameters:
  • rgb_r (float) – R coordinate. 0…1. 1-255 if is_upscaled=True.
  • rgb_g (float) – G coordinate. 0…1. 1-255 if is_upscaled=True.
  • rgb_b (float) – B coordinate. 0…1. 1-255 if is_upscaled=True.
  • is_upscaled (bool) – If False, RGB coordinate values are beteween 0.0 and 1.0. If True, RGB values are between 1 and 255.
get_rgb_hex()

Converts the RGB value to a hex value in the form of: #RRGGBB

Return type:str
get_upscaled_value_tuple()

Scales an RGB color object from decimal 0.0-1.0 to int 0-255.

get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

classmethod new_from_rgb_hex(hex_str)

Converts an RGB hex string like #RRGGBB and assigns the values to this sRGBColor object.

Return type:sRGBColor
clamped_rgb_b

The clamped (0.0-1.0) B value.

clamped_rgb_g

The clamped (0.0-1.0) G value.

clamped_rgb_r

The clamped (0.0-1.0) R value.

native_illuminant = 'd65'

The RGB space’s native illuminant. Important when converting to XYZ.

rgb_gamma = 2.2

RGB space’s gamma constant.

HSLColor

class colormath.color_objects.HSLColor(hsl_h, hsl_s, hsl_l)[source]

Bases: colormath.color_objects.ColorBase

Represents an HSL color.

Parameters:
  • hsl_h (float) – H coordinate.
  • hsl_s (float) – S coordinate.
  • hsl_l (float) – L coordinate.
get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

hsl_h = None

H coordinate

hsl_l = None

L coordinate

hsl_s = None

S coordinate

HSVColor

class colormath.color_objects.HSVColor(hsv_h, hsv_s, hsv_v)[source]

Bases: colormath.color_objects.ColorBase

Represents an HSV color.

Parameters:
  • hsv_h (float) – H coordinate.
  • hsv_s (float) – S coordinate.
  • hsv_v (float) – V coordinate.
get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

hsv_h = None

H coordinate

hsv_s = None

S coordinate

hsv_v = None

V coordinate

CMYColor

class colormath.color_objects.CMYColor(cmy_c, cmy_m, cmy_y)[source]

Bases: colormath.color_objects.ColorBase

Represents a CMY color.

Parameters:
  • cmy_c (float) – C coordinate.
  • cmy_m (float) – M coordinate.
  • cmy_y (float) – Y coordinate.
get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

cmy_c = None

C coordinate

cmy_m = None

M coordinate

cmy_y = None

Y coordinate

CMYKColor

class colormath.color_objects.CMYKColor(cmyk_c, cmyk_m, cmyk_y, cmyk_k)[source]

Bases: colormath.color_objects.ColorBase

Represents a CMYK color.

Parameters:
  • cmyk_c (float) – C coordinate.
  • cmyk_m (float) – M coordinate.
  • cmyk_y (float) – Y coordinate.
  • cmyk_k (float) – K coordinate.
get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

cmyk_c = None

C coordinate

cmyk_k = None

K coordinate

cmyk_m = None

M coordinate

cmyk_y = None

Y coordinate

IPTColor

class colormath.color_objects.IPTColor(ipt_i, ipt_p, ipt_t)[source]

Bases: colormath.color_objects.ColorBase

Represents an IPT color.

Reference: Fairchild, M. D. (2013). Color appearance models, 3rd Ed. (pp. 271-272). John Wiley & Sons.

Parameters:
  • ipt_i – I coordinate.
  • ipt_p – P coordinate.
  • ipt_t – T coordinate.
get_value_tuple()

Returns a tuple of the color’s values (in order). For example, an LabColor object will return (lab_l, lab_a, lab_b), where each member of the tuple is the float value for said variable.

ipt_i = None

I coordinate

ipt_p = None

P coordinate

ipt_t = None

T coordinate

Observers and Illuminants

Illuminants and observer angles are used in all color spaces that use reflective (instead of transmissive) light. Here are a few brief overviews of what these are and what they do:

To adjust the illuminants and/or observer angles on a color:

lab = LabColor(0.1, 0.2, 0.3, observer='10', illuminant='d65')

Two-degree observer angle

These illuminants can be used with observer='2', for the color spaces that require illuminant/observer:

  • 'a'
  • 'b'
  • 'c'
  • 'd50'
  • 'd55'
  • 'd65'
  • 'd75'
  • 'e'
  • 'f2'
  • 'f7'
  • 'f11'

Ten-degree observer angle

These illuminants can be used with observer='10', for the color spaces that require illuminant/observer:

  • 'd50'
  • 'd55'
  • 'd65'
  • 'd75'

Color Conversions

Converting between color spaces is very simple with python-colormath. To see a full list of supported color spaces, see Color Objects.

All conversions happen through the convert_color function shown below. The original Color instance is passed in as the first argument, and the desired Color class (not an instance) is passed in as the second argument. If the conversion can be made, a new Color instance will be returned.

colormath.color_conversions.convert_color(color, target_cs, through_rgb_type=<class 'colormath.color_objects.sRGBColor'>, target_illuminant=None, *args, **kwargs)[source]

Converts the color to the designated color space.

Parameters:
  • color – A Color instance to convert.
  • target_cs – The Color class to convert to. Note that this is not an instance, but a class.
  • through_rgb_type (BaseRGBColor) – If during your conversion between your original and target color spaces you have to pass through RGB, this determines which kind of RGB to use. For example, XYZ->HSL. You probably don’t need to specify this unless you have a special usage case.
  • target_illuminant (None or str) – If during conversion from RGB to a reflective color space you want to explicitly end up with a certain illuminant, pass this here. Otherwise the RGB space’s native illuminant will be used.
Returns:

An instance of the type passed in as target_cs.

Raises:

colormath.color_exceptions.UndefinedConversionError if conversion between the two color spaces isn’t possible.

Example

This is a simple example of a CIE Lab to CIE XYZ conversion. Refer to Color Objects for a full list of different color spaces that can be instantiated and converted between.

from colormath.color_objects import LabColor, XYZColor
from colormath.color_conversions import convert_color

lab = LabColor(0.903, 16.296, -2.22)
xyz = convert_color(lab, XYZColor)

Some color spaces require a trip through RGB during conversion. For example, to get from XYZ to HSL, we have to convert XYZ->RGB->HSL. The same could be said for XYZ to CMYK (XYZ->RGB->CMY->CMYK). Different RGB color spaces have different gamut sizes and capabilities, which can affect your converted color values.

sRGB is the default RGB color space due to its ubiquity. If you would like to use a different RGB space for a conversion, you can do something like this:

from colormath.color_objects import XYZColor, HSLColor, AdobeRGBColor
from colormath.color_conversions import convert_color

xyz = XYZColor(0.1, 0.2, 0.3)
hsl = convert_color(xyz, HSLColor, through_rgb_type=AdobeRGBColor)
# If you are going to convert back to XYZ, make sure you use the same
# RGB color space on the way back.
xyz2 = convert_color(hsl, XYZColor, through_rgb_type=AdobeRGBColor)

RGB conversions and native illuminants

When converting RGB colors to any of the CIE spaces, we have to pass through the XYZ color space. This serves as a crossroads for conversions to basically all of the reflective color spaces (CIE Lab, LCH, Luv, etc). The RGB spaces are reflective, where the illumination is provided. In the case of a reflective space like XYZ, the illuminant must be supplied by a light source.

Each RGB space has its own native illuminant, which can vary from space to space. To see some of these for yourself, check out Bruce Lindbloom’s XYZ to RGB matrices.

To cite the most commonly used RGB color space as an example, sRGB has a native illuminant of D65. When we convert RGB to XYZ, that native illuminant carries over unless explicitly overridden. If you aren’t expecting this behavior, you’ll end up with variations in your converted color’s numbers.

To explicitly request a specific illuminant, provide the target_illuminant keyword when using colormath.color_conversions.convert_color().

from colormath.color_objects import XYZColor, sRGBColor
from colormath.color_conversions import convert_color

rgb = RGBColor(0.1, 0.2, 0.3)
xyz = convert_color(rgb, XYZColor, target_illuminant='d50')

RGB conversions and out-of-gamut coordinates

RGB spaces tend to have a smaller gamut than some of the CIE color spaces. When converting to RGB, this can cause some of the coordinates to end up being out of the acceptable range (0.0-1.0 or 1-255, depending on whether your RGB color is upscaled).

Rather than clamp these for you, we leave them as-is. This allows for more accurate conversions back to the CIE color spaces. If you require the clamped (0.0-1.0 or 1-255) values, use the following properties on any RGB color:

  • clamped_rgb_r
  • clamped_rgb_g
  • clamped_rgb_b

Delta E Equations

Delta E equations are used to put a number on the visual difference between two LabColor instances. While different lighting conditions, substrates, and physical condition can all introduce unexpected variables, these equations are a good rough starting point for comparing colors.

Each of the following Delta E functions has different characteristics. Some may be more suitable for certain applications than others. While it’s outside the scope of this module’s documentation to go into much detail, we link to relevant material when possible.

Example

from colormath.color_objects import LabColor
from colormath.color_diff import delta_e_cie1976

# Reference color.
color1 = LabColor(lab_l=0.9, lab_a=16.3, lab_b=-2.22)
# Color to be compared to the reference.
color2 = LabColor(lab_l=0.7, lab_a=14.2, lab_b=-1.80)
# This is your delta E value as a float.
delta_e = delta_e_cie1976(color1, color2)

Delta E CIE 1976

colormath.color_diff.delta_e_cie1976(color1, color2)[source]

Calculates the Delta E (CIE1976) of two colors.

Delta E CIE 1994

colormath.color_diff.delta_e_cie1994(color1, color2, K_L=1, K_C=1, K_H=1, K_1=0.045, K_2=0.015)[source]

Calculates the Delta E (CIE1994) of two colors.

K_l:
0.045 graphic arts 0.048 textiles
K_2:
0.015 graphic arts 0.014 textiles
K_L:
1 default 2 textiles

Delta E CIE 2000

colormath.color_diff.delta_e_cie2000(color1, color2, Kl=1, Kc=1, Kh=1)[source]

Calculates the Delta E (CIE2000) of two colors.

Delta E CMC

colormath.color_diff.delta_e_cmc(color1, color2, pl=2, pc=1)[source]

Calculates the Delta E (CMC) of two colors.

CMC values
Acceptability: pl=2, pc=1 Perceptability: pl=1, pc=1

ANSI and ISO Density

Density may be calculated from LabColor instances.

colormath.density.auto_density(color)[source]

Given a SpectralColor, automatically choose the correct ANSI T filter. Returns a tuple with a string representation of the filter the calculated density.

Parameters:color (SpectralColor) – The SpectralColor object to calculate density for.
Return type:float
Returns:The density value, with the filter selected automatically.
colormath.density.ansi_density(color, density_standard)[source]

Calculates density for the given SpectralColor using the spectral weighting function provided. For example, ANSI_STATUS_T_RED. These may be found in colormath.density_standards.

Parameters:
  • color (SpectralColor) – The SpectralColor object to calculate density for.
  • density_standard (numpy.ndarray) – NumPy array of filter of choice from colormath.density_standards.
Return type:

float

Returns:

The density value for the given color and density standard.

Example

from colormath.color_objects import SpectralColor
from colormath.density import auto_density, ansi_density
from colormath.density_standards import ANSI_STATUS_T_RED

# Omitted the full spectral kwargs for brevity.
color = SpectralColor(spec_340nm=0.08, ...)
# ANSI T Density for the spectral color.
density = auto_density(color)

# Or maybe we want to specify which filter to use.
red_density = ansi_density(color, ANSI_STATUS_T_RED)

Valid Density Constants

The following density constants within colormath.density_standards can be passed to colormath.density.ansi_density():

  • ANSI_STATUS_A_RED
  • ANSI_STATUS_A_GREEN
  • ANSI_STATUS_A_BLUE
  • ANSI_STATUS_E_RED
  • ANSI_STATUS_E_GREEN
  • ANSI_STATUS_E_BLUE
  • ANSI_STATUS_M_RED
  • ANSI_STATUS_M_GREEN
  • ANSI_STATUS_M_BLUE
  • ANSI_STATUS_T_RED
  • ANSI_STATUS_T_GREEN
  • ANSI_STATUS_T_BLUE
  • TYPE1
  • TYPE2
  • ISO_VISUAL

Color Appearance Models

Color appearance models allow the prediction of perceptual correlates (e.g., lightness, chroma or hue) of a given surface color under certain viewing conditions (e.g., a certain illuminant, surround or background). The complexity of color appearance models can range from very low, e.g., CIELAB can technically be considered a color appearance model, to very complex models that take into account a large number color appearance phenomena.

Each of the classes in this module represents a specific model and its computation, yielding the predicted perceptual correlates as instance attributes. Discussing the details of each model go beyond this documentation, but we provide references to the relevant literature for each model and would advice familiarising yourself with it, before using a given models.

Example

# Color stimulus
color = XYZColor(19.01, 20, 21.78)

# The two illuminants that will be compared.
illuminant_d65 = XYZColor(95.05, 100, 108.88)
illuminant_a = XYZColor(109.85, 100, 35.58)

# Background relative luminance
y_b = 20

# Adapting luminance
l_a = 328.31

# Surround condition assumed to be average (see CIECAM02 documentation for values)
c = 0.69
n_c = 1
f = 1

model = CIECAM02(color.xyz_x, color.xyz_y, color.xyz_z,
                 illuminant_d65.xyz_x, illuminant_d65.xyz_y, illuminant_d65.xyz_z,
                 y_b, l_a, c, n_c, f)

Nayatani95 et al. Model

class colormath.color_appearance_models.Nayatani95(x, y, z, x_n, y_n, z_n, y_ob, e_o, e_or, n=1)[source]

Bases: object

References

  • Fairchild, M. D. (2013). Color appearance models, 3rd Ed. John Wiley & Sons.
  • Nayatani, Y., Sobagaki, H., & Yano, K. H. T. (1995). Lightness dependency of chroma scales of a nonlinear color-appearance model and its latest formulation. Color Research & Application, 20(3), 156-167.
Parameters:
  • x – X value of test sample \(X\).
  • y – Y value of test sample \(Y\).
  • z – Z value of test sample \(Z\).
  • x_n – X value of reference white \(X_n\).
  • y_n – Y value of reference white \(Y_n\).
  • z_n – Z value of reference white \(Z_n\).
  • y_ob – Luminance factor of achromatic background as percentage \(Y_o\). Required to be larger than 0.18.
  • e_o – Illuminance of the viewing field \(E_o\) in lux.
  • e_or – Normalising illuminance \(E_or\) in lux.
  • n – Noise term \(n\).
brightness

Predicted brightness \(B_r\).

chroma

Predicted chroma \(C\).

colorfulness

Predicted colorfulness \(M\).

hue_angle

Predicted hue angle \(\theta\).

saturation

Predicted saturation \(S\).

Hunt Model

class colormath.color_appearance_models.Hunt(x, y, z, x_b, y_b, z_b, x_w, y_w, z_w, l_a, n_c, n_b, l_as=None, cct_w=None, n_cb=None, n_bb=None, x_p=None, y_p=None, z_p=None, p=None, helson_judd=False, discount_illuminant=True, s=None, s_w=None)[source]

Bases: object

References

  • Fairchild, M. D. (2013). Color appearance models, 3rd Ed. John Wiley & Sons.
  • Hunt, R. W. G. (2005). The reproduction of colour. 5th Ed., John Wiley & Sons.
Parameters:
  • x – X value of test sample \(X\).
  • y – Y value of test sample \(Y\).
  • z – Z value of test sample \(Z\).
  • x_b – X value of background \(X_b\).
  • y_b – Y value of background \(Y_b\).
  • z_b – Z value of background \(Z_b\).
  • x_w – X value of reference white \(X_W\).
  • y_w – Y value of reference white \(Y_W\).
  • z_w – Z value of reference white \(Z_W\).
  • l_a – Adapting luminance \(L_A\).
  • n_c – Chromatic surround induction_factor \(N_c\).
  • n_b – Brightness surround induction factor \(N_b\).
  • l_as – Scotopic luminance of the illuminant \(L_{AS}\). Will be approximated if not supplied.
  • cct_w – Correlated color temperature of illuminant \(T\). Will be used to approximate l_as if not supplied.
  • n_cb – Chromatic background induction factor \(N_{cb}\). Will be approximated using y_w and y_b if not supplied.
  • n_bb – Brightness background induction factor \(N_{bb}\). Will be approximated using y_w and y_b if not supplied.
  • x_p – X value of proxima field \(X_p\). If not supplied, will be assumed to equal background.
  • y_p – Y value of proxima field \(Y_p\). If not supplied, will be assumed to equal background.
  • z_p – Z value of proxima field \(Z_p\). If not supplied, will be assumed to equal background.
  • p – Simultaneous contrast/assimilation parameter.
  • helson_judd – Truth value indicating whether the Heslon-Judd effect should be accounted for. Default False.
  • discount_illuminant – Truth value whether discount-the-illuminant should be applied. Default True.
  • s – Scotopic response to the stimulus.
  • s_w – Scotopic response for th reference white.
Raises:

ValueError – if illegal parameter combination is supplied.

brightness

Predicted brightness \(Q\).

chroma

Predicted chroma \(C_{94}\).

colorfulness

Predicted colorfulness \(M_{94}\).

hue_angle

Predicted hue angle \(h_s\).

lightness

Predicted colorfulness \(J\).

saturation

Predicted saturation \(s\).

RLAB Model

class colormath.color_appearance_models.RLAB(x, y, z, x_n, y_n, z_n, y_n_abs, sigma, d)[source]

Bases: object

References

  • Fairchild, M. D. (1996). Refinement of the RLAB color space. Color Research & Application, 21(5), 338-346.
  • Fairchild, M. D. (2013). Color appearance models, 3rd Ed. John Wiley & Sons.
Parameters:
  • x – X value of test sample \(X\).
  • y – Y value of test sample \(Y\).
  • z – Z value of test sample \(Z\).
  • x_n – X value of reference white \(X_n\).
  • y_n – Y value of reference white \(Y_n\).
  • z_n – Z value of reference white \(Z_n\).
  • y_n_abs – Absolute luminance \(Y_n\) of a white object in cd/m^2.
  • sigma – Relative luminance parameter \(\sigma\). For average surround set \(\sigma=1/2.3\), for dim surround \(\sigma=1/2.9\) and for dark surround \(\sigma=1/3.5\).
  • d – Degree of adaptation \(D\).
a

Predicted red-green chromatic response \(a^R\).

b

Predicted yellow-blue chromatic response \(b^R\).

chroma

Predicted chroma \(C^R\).

hue_angle

Predicted hue angle \(h^R\).

lightness

Predicted colorfulness \(L^R\).

saturation

Predicted saturation \(s^R\).

ATD95 Model

class colormath.color_appearance_models.ATD95(x, y, z, x_0, y_0, z_0, y_0_abs, k_1, k_2, sigma=300)[source]

Bases: object

References

  • Fairchild, M. D. (2013). Color appearance models, 3rd Ed. John Wiley & Sons.
  • Guth, S. L. (1995, April). Further applications of the ATD model for color vision. In IS&T/SPIE’s Symposium on Electronic Imaging: Science & Technology (pp. 12-26). International Society for Optics and Photonics.
Parameters:
  • x – X value of test sample \(X\).
  • y – Y value of test sample \(Y\).
  • z – Z value of test sample \(Z\).
  • x_0 – X value of reference white \(X_0\).
  • y_0 – Y value of reference white \(Y_0\).
  • z_0 – Z value of reference white \(Z_0\).
  • y_0_abs – Absolute adapting luminance \(Y_0\) in cd/m^2.
  • k_1\(k_1\)
  • k_2\(k_2\)
  • sigma\(\sigma\)
brightness

Predicted brightness \(Br\).

hue

Predicted hue \(H\).

saturation

Predicted saturation \(C\).

LLAB Model

class colormath.color_appearance_models.LLAB(x, y, z, x_0, y_0, z_0, y_b, f_s, f_l, f_c, l, d=1)[source]

Bases: object

References

  • Fairchild, M. D. (2013). Color appearance models, 3rd Ed. John Wiley & Sons.
  • Luo, M. R., & Morovic, J. (1996, September). Two unsolved issues in colour management-colour appearance and gamut mapping. In 5th International Conference on High Technology (pp. 136-147).
  • Luo, M. R., Lo, M. C., & Kuo, W. G. (1996). The LLAB (l: c) colour model. Color Research & Application, 21(6), 412-429.
Parameters:
  • x – X value of test sample \(X\).
  • y – Y value of test sample \(Y\).
  • z – Z value of test sample \(Z\).
  • x_0 – X value of reference white \(X_0\).
  • y_0 – Y value of reference white \(Y_0\).
  • z_0 – Z value of reference white \(Z_0\).
  • y_b – Luminance factor of the background \(Y_b\) in cd/m^2.
  • f_s – Surround induction factor \(F_S\).
  • f_l – Lightness induction factor \(F_L\).
  • f_c – Chroma induction factor \(F_C\).
  • l – Absolute luminance of reference white \(L\) in cd/m^2.
  • d – Discounting-the-Illuminant factor \(D\).
a_l

Predicted red-green chromatic response \(A_L\).

b_l

Predicted yellow-blue chromatic response \(B_L\).

chroma

Predicted chroma \(Ch_L\).

hue_angle

Predicted hue angle \(h_L\).

lightness

Predicted colorfulness \(L_L\).

saturation

Predicted saturation \(s_L\).

CIECAM02 Model

class colormath.color_appearance_models.CIECAM02(x, y, z, x_w, y_w, z_w, y_b, l_a, c, n_c, f, d=False)[source]

Bases: object

References

  • CIE TC 8-01 (2004). A Color appearance model for color management systems. Publication 159. Vienna: CIE Central Bureau. ISBN 3-901906-29-0.
  • Fairchild, M. D. (2013). Color appearance models, 3rd Ed. John Wiley & Sons.
Parameters:
  • x – X value of test sample \(X\).
  • y – Y value of test sample \(Y\).
  • z – Z value of test sample \(Z\).
  • x_w – X value of reference white \(X_W\).
  • y_w – Y value of reference white \(Y_W\).
  • z_w – Z value of reference white \(Z_W\).
  • y_b – Background relative luminance \(Y_b\).
  • l_a – Adapting luminance \(L_A\) in cd/m^2.
  • c – Exponential nonlinearity \(c\). (Average/Dim/Dark) (0.69/0.59/0.525).
  • n_c – Chromatic induction factor \(N_c\). (Average/Dim/Dark) (1.0,0.9,0.8).
  • f – Maximum degree of adaptation \(F\). (Average/Dim/Dark) (1.0/0.9/0.8).
  • d – Discount-the-Illuminant factor \(D\).
a

Predicted red-green chromatic response \(a\).

b

Predicted yellow-blue chromatic response \(b\).

brightness

Predicted colorfulness \(Q\).

chroma

Predicted chroma \(C\).

colorfulness

Predicted colorfulness \(M\).

hue_angle

Predicted hue angle \(h\).

lightness

Predicted colorfulness \(J\).

saturation

Predicted saturation \(s_L\).

CIECAM02-m1 Model

class colormath.color_appearance_models.CIECAM02m1(x, y, z, x_w, y_w, z_w, x_b, y_b, z_b, l_a, c, n_c, f, p, d=False)[source]

Bases: colormath.color_appearance_models.CIECAM02

References

  • Wu, R. C., & Wardman, R. H. (2007). Proposed modification to the CIECAM02 colour appearance model to include the simultaneous contrast effects. Color Research & Application, 32(2), 121-129.
Parameters:
  • x – X value of test sample \(X\).
  • y – Y value of test sample \(Y\).
  • z – Z value of test sample \(Z\).
  • x_w – X value of reference white \(X_W\).
  • y_w – Y value of reference white \(Y_W\).
  • z_w – Z value of reference white \(Z_W\).
  • x_b – X value of background \(X_b\).
  • y_b – Y value of background \(Y_b\).
  • z_b – Z value of background \(Z_b\).
  • l_a – Adapting luminance \(L_A\) in cd/m^2.
  • c – Exponential nonlinearity \(c\). (Average/Dim/Dark) (0.69/0.59/5.25).
  • n_c – Chromatic induction factor \(N_c\). (Average/Dim/Dark) (1.0,0.9,0.8).
  • f – Maximum degree of adaptation \(F\). (Average/Dim/Dark) (1.0/0.9/0.8).
  • p – Simultaneous contrast/assimilation parameter.
  • d – Discount-the-Illuminant factor \(D\).
a

Predicted red-green chromatic response \(a\).

b

Predicted yellow-blue chromatic response \(b\).

brightness

Predicted colorfulness \(Q\).

chroma

Predicted chroma \(C\).

colorfulness

Predicted colorfulness \(M\).

hue_angle

Predicted hue angle \(h\).

lightness

Predicted colorfulness \(J\).

saturation

Predicted saturation \(s_L\).

Release Notes

3.0.0

Features
  • Python 3.5 and 3.6 are now supported.
Backwards-Incompatible Changes
  • Python 3.3 and 3.4 are no longer supported.
  • networkx>=2.0 is now required.
Bug Fixes
  • Add NodeNotFound to GraphConversionManager.get_conversion_path().

2.2.0

Features
  • AppleRGBColor added. (jan-warchol)
  • Added compatibility with NetworkX 2.0. (Erotemic)
Bug Fixes
  • IPT_to_XYZ docstring corrected. (mumbleskates)

2.1.1

Bug Fixes
  • Add network to install_requires. (Ed-von-Schleck)

2.1.0

Features
  • Added new NetworkX graph-based resolution of conversions between color spaces. Reduces boilerplate and makes it much easier to add additional color spaces going forward. (MichaelMauderer)
  • Added the IPT color space. (MichaelMauderer)
  • Added Color Appearance Models. Natayani95, Hunt, RLAB, ATD95, LLAB, CIECAM02, CIECAM02-m1. (MichaelMauderer)
Bug Fixes
  • xyY conversions now correctly avoid division by zero. (dwbullok)
  • Un-transposed adaptation matrices. Has no effect on conversions, but if you use these directly you may see different numbers. (JasonTam)
  • During XYZ->RGB, linear channel values are now clamped in order to avoid domain errors. Output should now always be between 0 and 1.
Backwards Incompatible changes
  • If any of your code directly referenced the color adaptation matrices that were un-inverted, you’ll need to adjust your math.

2.0.2

Bug Fixes
  • Apparently I didn’t add the function body for the clamped RGB properties. Yikes.

2.0.1

Features
  • Lots of documentation improvements.
  • convert_color() now has an explicitly defined/documented target_illuminant kwarg, instead of letting this fall through to its **kwargs. This should make IDE auto-complete better and provide more clarity.
  • Added clamped_rgb_r, clamped_rgb_g, and clamped_rgb_b to RGB color spaces. Use these if you have to have in-gamut, potentially compressed coordinates.
Bug Fixes
  • Direct conversions to non-sRGB colorspaces returned sRGBColor objects. Reported by Cezary Wagner.

2.0.0

Backwards Incompatible changes
  • Minimum Python version is now 2.7.
  • ColorBase.convert_to() is no more. Use colormath.color_conversions.convert_color() instead. API isn’t as spiffy looking, but it’s a lot less magical now.
  • Completely re-worked RGB handling. Each RGB space now has its own class, inheriting from BaseRGBColor. Consequently, RGBColor is no more. In most cases, you can substitute RGBColor with sRGBColor during your upgrade.
  • RGB channels are now [0..1] instead of [1..255]. Can use BaseRGBColor.get_upscaled_value_tuple() to get the upscaled values.
  • BaseRGBColor.set_from_rgb_hex() was replaced with a BaseRGBColor.new_from_rgb_hex(), which returns a properly formed sRGBColor object.
  • BaseRGBColor no longer accepts observer or illuminant kwargs.
  • HSL no longer accepts observer, illuminant or rgb_type kwargs.
  • HSV no longer accepts observer, illuminant or rgb_type kwargs.
  • CMY no longer accepts observer, illuminant or rgb_type kwargs.
  • CMYK no longer accepts observer, illuminant or rgb_type kwargs.
  • Removed ‘debug’ kwargs in favor of Python’s logging.
  • Completely re-worked exception list. Eliminated some redundant exceptions, re-named basically everything else.
Features
  • Python 3.3 support added.
  • Added tox.ini with supported environments.
  • Removed the old custom test runner in favor of nose.
  • Replacing simplified RGB->XYZ conversions with Bruce Lindbloom’s.
  • A round of PEP8 work.
  • Added a BaseColorConversionTest test class with some greatly improved color comparison. Much more useful in tracking down breakages.
  • Eliminated non-matrix delta E computations in favor of the matrix equivalents. No need to maintain duplicate code, and the matrix stuff is faster for bulk operations.
Bug Fixes
  • Corrected delta_e CMC example error. Should now run correctly.
  • color_diff_matrix.delta_e_cie2000 had an edge case where certain angles would result in an incorrect delta E.
  • Un-hardcoded XYZColor.apply_adaptation()’s adaptation and observer angles.

1.0.9

Features
  • Added an optional vectorized deltaE function. This uses NumPy array/matrix math for a very large speed boost. (Eddie Bell)
  • Added this changelog.
Bug Fixes
  • Un-hardcode the observer angle in adaptation matrix. (Bastien Dejean)

1.0.8

  • Initial GitHub release.

Useful color math resources