clojure2d.color — clojure2d 1.0.2

Color functions.

This namespace contains color manipulation functions which can be divided into following groups:

• Representation
• Channel manipulations
• Conversions
• Blending
• Palettes / gradients
• Distances

Representation

Color can be represented by following types:

• fastmath Vec4 - this is core type representing 3 color channels and alpha (RGBA). Values are double type from [0-255] range. color, gray creators returns Vec4 representation. To ensure Vec4 use [[to-color]] function.
• fastmath Vec3 - 3 color channels, assuming alpha set to value of 255.
• java.awt.Color - Java AWT representation. Creators are awt-color, awt-gray. Use [[to-awt-color]] to convert to this representations.
• keyword - one of the defined names (see named-colors-list)
• Integer - packed ARGB value. Example: 0xffaa01.
• String - CSS ("#ab1122") or 6 chars string containg hexadecimal representation ("ffaa01")
• any seqable - list, vector containing 2-4 elements. Conversion is done by applying content to color function.
• nil - returning nil during color conversion.

To create color from individual channel values use color function. To create gray for given intensity call gray.

By default color is treated as RGB with values from ranges [0.0-255.0] inclusive.

Coloured list of all names

Color/ channel manipulations

You can access individual channels by calling on of the following:

• [[red]] or [[ch0]] - to get first channel value.
• [[green]] or [[ch1]] - to get second channel value.
• [[blue]] or [[ch2]] - to get third channel value.
• [[alpha]] - to get alpha value.
• [[luma]] - to get luma or brightness (range from 0 (black) to 255 (white)).
• hue - to get hue value in degrees (range from 0 to 360). Hexagon projection.
• hue-polar - to get hue from polar transformation.

set-ch0, set-ch1, set-ch2 and set-alpha return new color with respective channel set to new value.

To make color darker/brighter use darken / [[lighten]] functions. Operations are done in Lab color space.

To change saturation call saturate / desaturate. Operations are done in LCH color space.

You can also rely on VectorProto from fastmath library and treat colors as vectors.

Conversions

Color can be converted from RGB to other color space (and back). List of color spaces are listed under colorspaces-list variable. There are two types of conversions:

• raw - with names to-XXX and from-XXX where XXX is color space name. Every color space has it's own value range for each channel. (comp from-XXX to-XXX) acts almost as identity.
• normalized - with names to-XXX* and from-XXX* where XXX is color space name. to-XXX* returns values normalized to [0-255] range. from-XXX* expects also channel values in range [0-255].

NOTE: there is no information which color space is used. It's just a matter of your code interpretation.

Color space conversion functions are collected in two maps colorspaces for raw and colorspaces* for normalized functions. Keys are color space names as keyword and values are vectors with to- fn as first and from- fn as second element.

Blending

You can blend two colors (or individual channels) using one of the methods from blends-list. All functions are collected in blends map with names as names and blending function as value.

Palettes / gradients

Links

List of all defined colors and palettes:

• Named palettes
• Colourlovers palettes
• Gradients

Palette

Palette is just sequence of colors.

There are plenty of them predefined or can be generated:

• colourlovers-palettes contains 500 top palettes in vector from colourlovers website.
• palette-presets contains 256 Brewer, categorical, veridis, tableau, microsoft palettes as map. See palette-presets-list for names.
• [[paletton-palette]] function to generate palette of type: :monochromatic, :triad, :tetrad with complementary color for given hue and configuration. See also Paletton website for details.

Gradient

Gradient is continuous functions which accepts value from [0-1] range and returns color. Call gradient, gradient-easing or iq-gradient to create one.

Predefined gradients are collected in gradient-presets map. You can find them cubehelix based and generated from Inigo Quilez settings.

Conversions

To convert palette to gradient call gradient function. You can set interpolation method and colorspace.

To convert gradient to palette call sample function from fastmath library.

Call resample to resample palette to other number of colors. Internally input palette is converted to gradient and sampled back.

To make gradient from two colors you can use also gradient-easing where you interpolate between to colors using one of the easings functions from fastmath.

Linear gradient between colors is defined as lerp function.

Distances

Several functions to calculate distance between colors (euclidean, delta-xxx etc.).

Thi.ng interoperability

Thi.ng RGBA type implements ColorProto. To convert any color to RGBA use to-thing-rgba.

*blend-threshold* clj

Some blend functions can be parametrized with threshold value. Default 0.5.

average clj

(average xs)

(average colorspace xs)

Average colors in given colorspace (default: :RGB)

awt-color clj

(awt-color c)

(awt-color c a)

(awt-color r g b)

(awt-color r g b a)

Create java.awt.Color object.

See also color, gray.

awt-gray clj

(awt-gray v)

(awt-gray v a)

Create grayscale color based on intensity v. Optional parameter alpha a.

AWT version of gray. See also awt-color

blend-add clj

(blend-add a b)

Add channel values.

blend-and clj

(blend-and a b)

Bitwise and of channel values.

blend-burn clj

(blend-burn a b)

Burn channel values.

blend-colors clj

(blend-colors f c1 c2)

(blend-colors f c1 c2 alpha?)

Blend colors with blending function. Set alpha? if you want to blend alpha channel (default: false).

blend-darken clj

(blend-darken a b)

Darken channel values.

blend-darkthreshold clj

(blend-darkthreshold a b)

(blend-darkthreshold a b thr)

Dark thresholded (with *blend-threshold*) channel values.

blend-difference clj

(blend-difference a b)

Difference channel values.

blend-divide clj

(blend-divide a b)

Divide channel values.

blend-dodge clj

(blend-dodge a b)

Dodge channel values.

blend-exclusion clj

(blend-exclusion a b)

Exclusion of channel values.

blend-hardlight clj

(blend-hardlight a b)

Hardlight channel values.

blend-hardmix clj

(blend-hardmix a b)

Hard mix channel values.

blend-lighten clj

(blend-lighten a b)

Lighten channel values.

blend-lightthreshold clj

(blend-lightthreshold a b)

(blend-lightthreshold a b thr)

Light thresholded (with *blend-threshold*) channel values.

blend-linearburn clj

(blend-linearburn a b)

Linear burn channel values.

blend-linearlight clj

(blend-linearlight a b)

Linear light channel values.

blend-madd clj

(blend-madd a b)

Modulus add channel values.

blend-mburn clj

(blend-mburn a b)

Modulus burn channel values.

blend-mdivide clj

(blend-mdivide a b)

Modulus divide channel values.

blend-mdodge clj

(blend-mdodge a b)

Modulus dodge channel values.

blend-mhardlight clj

(blend-mhardlight a b)

Modulus hardlight channel values.

blend-mlinearburn clj

(blend-mlinearburn a b)

Modulus linear burn channel values.

blend-mlinearlight clj

(blend-mlinearlight a b)

Modulus linear light channel values.

blend-moverlay clj

(blend-moverlay a b)

Modulus overlay channel values.

blend-mpegtoplight clj

(blend-mpegtoplight a b)

Modulus pegtop light channel values.

blend-mpinlight clj

(blend-mpinlight a b)

Modulus pinlight channel values.

blend-msoftlight clj

(blend-msoftlight a b)

Modulus softlight channel values.

blend-msubtract clj

(blend-msubtract a b)

Modulus subtract channel values.

blend-multiply clj

(blend-multiply a b)

Multiply channel values.

blend-mvividlight clj

(blend-mvividlight a b)

Modulus vividlight channel values.

blend-none clj

(blend-none a b)

Return first value only. Do nothing.

blend-opacity clj

(blend-opacity a b)

(blend-opacity a b thr)

Opacity (with *blend-threshold*)

blend-or clj

(blend-or a b)

Bitwise or of channel values.

blend-overlay clj

(blend-overlay a b)

Overlay channel values.

blend-pegtoplight clj

(blend-pegtoplight a b)

Pegtop light channel values.

blend-pinlight clj

(blend-pinlight a b)

Pinlight of channel values.

blend-screen clj

(blend-screen a b)

Screen channel values.

blend-softlight clj

(blend-softlight a b)

Softlight channel values.

blend-subtract clj

(blend-subtract a b)

Subtract channel values.

blend-values clj

(blend-values f a b)

Blend two values a and b from range [0,255] using blending function f.

Result is from range [0,255].

blend-vividlight clj

(blend-vividlight a b)

Vividlight channel values.

blend-xor clj

(blend-xor a b)

Bitwise xor of channel values.

blends clj

Map of all blending functions.

• key - name as keyword
• value - function

See blends-list for names.

blends-list clj

List of all blending functions.

brighten clj

Make color brighter. See darken.

change-lab-luma clj

(change-lab-luma amt col)

Change luma for givent color by given amount. Works in LAB color space.

Luma value can't exceed [0-100] range.

change-saturation clj

(change-saturation amt col)

Change color saturation in LCH color space.

Saturation value can't exceed [0-134] range.

clamp clj

(clamp c)

Clamp all color channels to [0-255] range.

clamp255 clj

(clamp255 a)

Constrain value a to 0-255 double.

Use to ensure that value is in RGB range. Accepts and returns double.

See also lclamp255, clamp and lclamp.

color clj

(color c)

(color c a)

(color r g b)

(color r g b a)

Create Vec4 object as color representation.

Arity:

• 1 - convert to Vec4 from any color. Same as [[to-color]]
• 2 - sets color alpha
• 3 - sets r,g,b with alpha 255
• 4 - sets r,g,b and alpha

See also awt-color, awt-gray.

color-converter clj

(color-converter cs)

(color-converter cs ch-scale)

(color-converter cs ch1-scale ch2-scale ch3-scale)

(color-converter cs ch1-scale ch2-scale ch3-scale ch4-scale)

Create fn which converts provided color from cs color space using ch-scale as maximum value. (to simulate Processing colorMode fn).

Arity:

• 1 - returns from-XXX* function
• 2 - sets the same maximum value for each channel
• 3 - sets individual maximum value without alpha, which is set to 0-255 range
• 4 - all channels have it's own indivudual maximum value.

ColorProto clj protocol

Basic color operations

to-color clj

(to-color c)

Convert any color representation to Vec4 vector.

green clj

(green c)

Returns green (second channel) value. See also [[ch1]].

ch2 clj

(ch2 c)

Returns third channel value. See also [[blue]]

to-awt-color clj

(to-awt-color c)

Convert any color representation to java.awt.Color.

ch0 clj

(ch0 c)

Returns first channel value. See also [[red]]

red clj

(red c)

Returns red (first channel) value. See also [[ch0]].

blue clj

(blue c)

Returns blue (third channel) value. See also [[ch2]].

ch1 clj

(ch1 c)

Returns second channel value. See also [[green]]

luma clj

(luma c)

Returns luma

alpha clj

(alpha c)

Returns alpha value.

colorspaces clj

Map of all color spaces functions

• key - name as keyword
• value - vector with functions containing to-XXX and from-XXX converters.

colorspaces* clj

Map of all normalized color spaces functions

• key - name as keyword
• value - vector with functions containing to-XXX* and from-XXX* converters.

colorspaces-list clj

List of all color space names.

colourlovers-palettes clj

Vector 500 best palettes taken from http://www.colourlovers.com/

See all

contrast-ratio clj

(contrast-ratio c1 c2)

WCAG contrast ratio.

Based on YUV luma.

darken clj

Make color darker. See brighten.

delta-c clj

(delta-c c1 c2)

Delta C* distance

delta-e-cie clj

Delta E CIE distance (euclidean in LAB colorspace.

delta-e-cmc clj

(delta-e-cmc c1 c2)

(delta-e-cmc l c c1 c2)

Delta E CMC distance.

Parameters l and c defaults to 1.0. Other common settings is l=2.0 and c=1.0.

delta-e-jab clj

(delta-e-jab c1 c2)

Delta e calculated in JAB color space.

delta-h clj

(delta-h c1 c2)

Delta H* distance

desaturate clj

Desaturate color

euclidean clj

Euclidean distance in RGB

format-hex clj

(format-hex c)

Convert color to hex string (css).

from-CMY clj

CMY -> RGB

from-CMY* clj

CMY -> RGB, alias for from-CMY

from-Cubehelix clj

(from-Cubehelix c)

Cubehelix -> RGB

from-Cubehelix* clj

(from-Cubehelix* c)

Cubehelix -> RGB, normalized

from-GLHS clj

(from-GLHS c)

GLHS -> RGB

from-GLHS* clj

(from-GLHS* c)

GLHS -> RGB

from-Gray clj

RGB -> Grayscale

from-Gray* clj

RGB -> Grayscale

from-HCL clj

(from-HCL c)

HCL -> RGB

from-HCL* clj

HCL -> RGB, normalized

from-HSB clj

HSB(V) -> RGB, normalized (see from-HSV)

from-HSB* clj

HSB(V) -> RGB (see [[from-HSV-raw]])

from-HSI clj

(from-HSI c)

HSI -> RGB

from-HSI* clj

HSI -> RGB, normalized

from-HSL clj

(from-HSL c)

HSL -> RGB

from-HSL* clj

HSL -> RGB, normalized

from-HSV clj

(from-HSV c)

HSV -> RGB

from-HSV* clj

HSV -> RGB, normalized

from-HunterLAB clj

(from-HunterLAB c)

HunterLAB -> RGB

from-HunterLAB* clj

(from-HunterLAB* c)

HunterLAB -> RGB, normalized

from-HWB clj

(from-HWB c)

HWB -> RGB

from-HWB* clj

(from-HWB* c)

HWB -> RGB, normalized

from-IPT clj

(from-IPT c)

IPT -> RGB

from-IPT* clj

(from-IPT* c)

LMS -> RGB, normalized

from-JAB clj

(from-JAB c)

JAB -> RGB

from-JAB* clj

(from-JAB* c)

JAB -> RGB, normalized

from-JCH clj

(from-JCH c)

JCH -> RGB

from-JCH* clj

(from-JCH* c)

JCH -> RGB, normalized

from-LAB clj

(from-LAB c)

LAB -> RGB

from-LAB* clj

(from-LAB* c)

LAB -> RGB, normalized

from-LCH clj

(from-LCH c)

LCH -> RGB

from-LCH* clj

(from-LCH* c)

LCH -> RGB, normalized

from-linear clj

(from-linear v)

Gamma correction (gamma=1/2.4), lighten

from-LMS clj

(from-LMS c)

LMS -> RGB, D65

from-LMS* clj

(from-LMS* c)

LMS -> RGB, normalized

from-LUV clj

(from-LUV c)

LUV -> RGB

from-LUV* clj

(from-LUV* c)

LUV -> RGB, normalized

from-OHTA clj

(from-OHTA c)

OHTA -> RGB

from-OHTA* clj

(from-OHTA* c)

OHTA -> RGB, normalized

from-RGB clj

Alias for [[to-color]]

from-RGB* clj

Alias for [[to-color]]

from-sRGB clj

(from-sRGB c)

sRGB -> RGB

from-sRGB* clj

sRGB -> RGB

from-XYZ clj

(from-XYZ c)

XYZ -> RGB

from-XYZ* clj

(from-XYZ* c)

XYZ -> RGB, normalized

from-YCbCr clj

(from-YCbCr c)

YCbCr -> RGB

from-YCbCr* clj

(from-YCbCr* c)

YCbCr -> RGB, normalized

from-YCgCo clj

(from-YCgCo c)

YCgCo -> RGB

from-YCgCo* clj

(from-YCgCo* c)

YCgCo -> RGB, normalized

from-YDbDr clj

(from-YDbDr c)

YDbDr -> RGB

from-YDbDr* clj

(from-YDbDr* c)

YDbDr -> RGB, normalized

from-YIQ clj

(from-YIQ c)

YIQ -> RGB

from-YIQ* clj

(from-YIQ* c)

YIQ -> RGB, normalized

from-YPbPr clj

(from-YPbPr c)

YPbPr -> RGB

from-YPbPr* clj

(from-YPbPr* c)

YPbPr -> RGB, normalized

from-YUV clj

(from-YUV c)

YUV -> RGB

from-YUV* clj

(from-YUV* c)

YUV -> RGB, normalized

from-Yxy clj

(from-Yxy c)

Yxy -> RGB

from-Yxy* clj

(from-Yxy* c)

Yxy -> RGB, normalized

gradient clj

(gradient palette)

(gradient colorspace palette)

(gradient colorspace interpolator palette)

(gradient colorspace interpolator domain palette)

Create gradient function from palette (list of colors).

Grandient function accepts value from 0 to 1 and returns interpolated color.

Optionally interpolate in given colorspace and 1d interpolator as keyword or function.

To make irregular spacings between colors, provide own domain.

gradient-cubehelix clj

Cubehelix gradient generator.

gradient-easing clj

(gradient-easing col1 col2)

(gradient-easing cs col1 col2)

(gradient-easing cs easing col1 col2)

Create gradient between two colors.

Input colors should be in expected color space (default: RGB).

You can use easing function to make interpolation non-linear (default: linear).

gradient-presets clj

Ready to use gradients containing Inigo Quilez, Cubehelix sets and other.

Map with name (keyword) as key and gradient function as value.

See all

gradient-presets-list clj

Gradient presets names.

gray clj

(gray v)

(gray v a)

Create grayscale color based on intensity v. Optional parameter alpha a.

See also color

hue clj

(hue c)

Hue value of color (any representation). Returns angle (0-360).

Uses hexagonal transformation. See also hue-polar.

hue-polar clj

(hue-polar c)

Hue value of color (any representation). Returns angle (0-360).

Uses polar transformation. See also hue.

iq-gradient clj

(iq-gradient c1 c2)

(iq-gradient a b c d)

Create gradient generator function with given parametrization or two colors.

See http://iquilezles.org/www/articles/palettes/palettes.htm and https://github.com/thi-ng/color/blob/master/src/gradients.org#gradient-coefficient-calculation

Parameters should be Vec3 type.

iq-random-gradient clj

(iq-random-gradient)

Create random iq gradient.

lclamp clj

(lclamp c)

Clamp all color channels to [0-255] range. Round if necessary.

lclamp255 clj

(lclamp255 a)

Constrain value a to 0-255 long (rounding if necessary).

Use to ensure that value is in RGB range.

See also clamp255, clamp and lclamp.

lerp clj

(lerp c1 c2 t)

Lineary interpolate color between two values.

See also gradient or fastmath vector interpolations.

mix clj

(mix x1 x2)

(mix x1 x2 t)

(mix colorspace x1 x2 t)

Mix colors in given optional colorspace (default: :RGB) and optional ratio (default: 0.5).

named-colors-list clj

List of html color names

Coloured list

nearest-color clj

(nearest-color xf c)

(nearest-color f xf c)

Find nearest color from a set. Input: distance function (default euclidean), list of target colors and source color.

noticable-different? clj

(noticable-different? c1 c2)

(noticable-different? s p c1 c2)

Returns noticable difference (true/false) between colors.

Defined in: https://research.tableau.com/sites/default/files/2014CIC_48_Stone_v3.pdf

Implementation from: https://github.com/connorgr/d3-jnd/blob/master/src/jnd.js

pack clj

(pack c)

Pack color to ARGB 32bit integer.

palette-presets clj

Color palette presets.

See all

palette-presets-list clj

Color palette presets list.

paletton clj multimethod

Create paletton palette.

Input:

• type - one of: :monochromatic (one hue), :triad (three hues), :tetrad (four hues)
• hue - paletton version of hue (use paletton-rgb-to-hue to get hue value).
• configuration as a map

Configuration consist:

• :preset - one of paletton-presets-list, default :full.
• :compl - generate complementary color?, default false. Works with :monochromatic and :triad
• :angle - hue angle for additional colors for :triad and :tetrad.
• :adj - for :triad only, generate adjacent (default true) values or not.

paletton-presets-list clj

Paletton presets names

paletton-rgb-to-hue clj

(paletton-rgb-to-hue c)

(paletton-rgb-to-hue r g b)

Convert color to paletton HUE (which is different than hexagon or polar conversion).

random-gradient clj

(random-gradient)

Generate random gradient function.

random-palette clj

(random-palette)

Generate random palette from all collections defined in clojure2d.color namespace.

reduce-colors clj

(reduce-colors xs number-of-colors)

(reduce-colors colorspace xs number-of-colors)

Reduce colors using x-means clustering in given colorspace (default :RGB).

Use for long sequences (for example to generate palette from image).

resample clj

(resample number-of-colors palette & gradient-params)

Resample palette.

Internally it's done by creating gradient and sampling back to colors. You can pass gradient parameters like colorspace, interpolator name and domain.

rev255 clj

Scaling factor to convert color value from range [0-255] to [0-1].

saturate clj

Saturate color

set-alpha clj

(set-alpha c a)

Set alpha channel and return new color

set-awt-alpha clj

(set-awt-alpha c a)

Set alpha channel and return Color representation.

set-ch0 clj

(set-ch0 c val)

Set alpha channel and return new color.

set-ch1 clj

(set-ch1 c val)

Set alpha channel and return new color.

set-ch2 clj

(set-ch2 c val)

Set alpha channel and return new color

to-CMY clj

(to-CMY c)

RGB -> CMY

to-CMY* clj

CMY -> RGB, alias for to-CMY

to-Cubehelix clj

(to-Cubehelix c)

RGB -> Cubehelix

to-Cubehelix* clj

(to-Cubehelix* c)

RGB -> Cubehelix, normalized

to-GLHS clj

(to-GLHS c)

RGB -> GLHS

to-GLHS* clj

(to-GLHS* c)

RGB -> GLHS, normalized

to-Gray clj

(to-Gray c)

RGB -> Grayscale

to-Gray* clj

RGB -> Grayscale

to-HCL clj

(to-HCL c)

RGB -> HCL

to-HCL* clj

RGB -> HCL, normalized

to-HSB clj

RGB -> HSB(V), normalized (see to-HSV)

to-HSB* clj

RGB -> HSB(V) (see [[to-HSV-raw]])

to-HSI clj

(to-HSI c)

RGB -> HSI

to-HSI* clj

RGB -> HSI, normalized

to-HSL clj

(to-HSL c)

RGB -> HSL

to-HSL* clj

RGB -> HSL, normalized

to-HSV clj

(to-HSV c)

RGB -> HSV

to-HSV* clj

RGB -> HSV, normalized

to-HunterLAB clj

(to-HunterLAB c)

RGB -> HunterLAB

to-HunterLAB* clj

(to-HunterLAB* c)

RGB -> HunterLAB, normalized

to-HWB clj

(to-HWB c)

RGB -> HWB

to-HWB* clj

(to-HWB* c)

RGB - HWB, normalized

to-IPT clj

(to-IPT c)

RGB -> IPT

to-IPT* clj

(to-IPT* c)

RGB -> IPT, normalized

to-JAB clj

(to-JAB c)

RGB -> JAB

to-JAB* clj

(to-JAB* c)

RGB -> JAB, normalized

to-JCH clj

(to-JCH c)

RGB -> JCH

to-JCH* clj

(to-JCH* c)

RGB -> JCH, normalized

to-LAB clj

(to-LAB c)

RGB -> LAB

to-LAB* clj

(to-LAB* c)

RGB -> LAB, normalized

to-LCH clj

(to-LCH c)

RGB -> LCH

to-LCH* clj

(to-LCH* c)

RGB -> LCH, normalized

to-linear clj

(to-linear v)

Gamma correction (gamma=2.4), darken

to-LMS clj

(to-LMS c)

RGB -> LMS, D65

to-LMS* clj

(to-LMS* c)

RGB -> LMS, normalized

to-LUV clj

(to-LUV c)

RGB -> LUV

to-LUV* clj

(to-LUV* c)

RGB -> LUV, normalized

to-OHTA clj

(to-OHTA c)

RGB -> OHTA

to-OHTA* clj

(to-OHTA* c)

RGB -> OHTA, normalized

to-RGB clj

Alias for [[to-color]]

to-RGB* clj

Alias for [[to-color]]

to-sRGB clj

(to-sRGB c)

RGB -> sRGB

to-sRGB* clj

RGB -> sRGB

to-thing-rgba clj

(to-thing-rgba c)

Convert Clojure2d color to thi.ng RGBA.

to-XYZ clj

(to-XYZ c)

RGB -> XYZ

to-XYZ* clj

(to-XYZ* c)

RGB -> XYZ, normalized

to-YCbCr clj

(to-YCbCr c)

RGB -> YCbCr

to-YCbCr* clj

(to-YCbCr* c)

RGB -> YCbCr, normalized

to-YCgCo clj

(to-YCgCo c)

RGB -> YCgCo

to-YCgCo* clj

(to-YCgCo* c)

RGB -> YCgCo, normalized

to-YDbDr clj

(to-YDbDr c)

RGB -> YDbDr

to-YDbDr* clj

(to-YDbDr* c)

RGB -> YDbDr

to-YIQ clj

(to-YIQ c)

RGB -> YIQ

to-YIQ* clj

(to-YIQ* c)

RGB -> YIQ, normalized

to-YPbPr clj

(to-YPbPr c)

RGB -> YPbPr

to-YPbPr* clj

(to-YPbPr* c)

RGB -> YPbPr, normalized

to-YUV clj

(to-YUV c)

RGB -> YUV

to-YUV* clj

(to-YUV* c)

RGB -> YUV, normalized

to-Yxy clj

(to-Yxy c)

RGB -> Yxy

to-Yxy* clj

(to-Yxy* c)

RGB -> Yxy, normalized