A library for dealing with Colors and pixels. It implements arbitrary color space conversion, chromatic adaptation and other color manipulations.

Language	Github Actions	Coveralls	Gitter.im

Package	Hackage	Nightly	LTS
Color

There is a clear separation between color models, color spaces and alternative representations of color spaces. All are distinct at the type level. The goal is to prevent mixups of incompatible color types as well as utilize type information for conversion between them.

Currently supported:

• Color models:

  • Y
  • RGB
  • HSI
  • HSL
  • HSV
  • YCbCr
  • CMYK

• Color spaces and arbitrary conversions between them:

  • Y - luminance

  • Y' - luma

  • CIE XYZ

  • CIE L*a*b*

  • RGB:

    • sRGB - both standardized and derived

    • AdobeRGB - both standardized and derived

    • ITU: Rec470, Rec601 and Rec709

    • Alternative representations:

      • HSI
      • HSL
      • HSV
      • YCbCr
      • CMYK

• Illuminants:

  • CIE1931 - 2 degree observer
  • CIE1964 - 10 degree observer
  • Some common alternatives

• Chromatic adaptation:

  • VonKries adaptation with transformations:

    • VonKries
    • Bradford (default)
    • Fairchild
    • CIECAM02
    • CMCCAT2000

• Color Standards:

  • RAL
  • SVG

Here is a short example how this library can be used. Here we assume a GHCi session that can be started like so:

$ stack ghci --package Color

Let's say we need find the perceived lightness as described in this StackOverflow answer for an RGB triple (128, 255, 65) :: (Word8, Word8, Word8).

Before we can attempt getting the lightness we need to do these two things:

1. Figure out what is the color space of the RGB triplet? In particular the Illuminant and the Linearity of the RGB color space.
2. Convert your RGB color to CIE L*a*b* and then we can get the L* out, which is the perceived lightness.

More often than not an RGB image will be encoded in non-linear sRGB color space with 8 bits per channel, so we'll use that for this example:

ghci> :set -XDataKinds
ghci> import Graphics.Color.Space
ghci> let rgb8 = ColorSRGB 128 255 65 :: Color (SRGB 'NonLinear) Word8
ghci> print rgb8
<SRGB 'NonLinear:(128,255, 65)>

Before we convert sRGB to CIE L*a*b* color space we need to increase the precision to Double, because for now Word8 is not supported by the LAB color space implementation:

ghci> let rgb = toDouble <$> rgb8
ghci> print rgb
<SRGB 'NonLinear:( 0.5019607843137255, 1.0000000000000000, 0.2549019607843137)>

In order to convert to another color space without changing the Illuminant we can use convertColor function. So here is how we convert to CIELAB and extract the perceived lightness L*:

ghci> let lab@(ColorLAB l _ _) = convertColor rgb :: Color (LAB D65) Double
ghci> lab
<LAB * D65:(90.0867507593648500,-65.7999116680496000,74.4643898323530600)>
ghci> l
90.08675075936485

When a change of Illuminant is also needed during color space conversion we can use convert function

ghci> import Graphics.Color.Adaptation (convert)
ghci> import qualified Graphics.Color.Illuminant.CIE1964 as CIE1964
ghci> let lab@(ColorLAB l _ _) = convert rgb :: Color (LAB 'CIE1964.D50) Double
ghci> lab
<LAB CIE1964 'D50:(90.2287735564601500,-59.3846969983265500,72.9304679742930800)>

• Color is on a list of curated Awesome Colour resources.

• While working on this library the colour-science.org and their Python implementation of colour was used extensively as a reference.