clojure2d.color — clojure2d 1.4.5

Color functions.

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

• Color creators
• Channel manipulations
• Conversions
• 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.
• fastmath Vec3 - 3 channels (RGB), assuming alpha set to value of 255.
• fastmath Vec2 - gray with alpha
• java.awt.Color - Java AWT representation. Creators are awt-color, awt-gray. Use to-awt-color to convert to this representation.
• keyword - one of the defined names (see named-colors-list)
• Integer - packed ARGB value. If value is less than 0xff000000, alpha is set to 0xff. Example: 0xffaa01.
• String - CSS (#rgb or #rgba) or string containg hexadecimal representation ("ffaa01")
• any seqable - list, vector containing 2-4 elements. Conversion is done by applying content to color function.

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.

All funtions internally convert any color representation to Vec4 type using to-color function..

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.

General set-channel and get-channel can work with any colorspace.

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 modulate color (ie. multiply by given value).

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 interpretation.

NOTE 2: be aware that converting function do not clamp any values to/from expected range.

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.

Palettes / gradients

Links

List of all defined colors and palettes:

• Named palettes
• Gradients

Palette

Palette is just sequence of colors.

There are plenty of them predefined or can be generated:

• palette to access palette by keyword (from presets), by number (from colourlovers). Use palette to resample palette or convert gradient to palette.
• [[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.

Call palette without any parameters to get list of predefined gradients.

Gradient

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

Call gradient without any parameters to obtain list of predefined gradients.

Use gradient to convert any palette to gradient or access predefined gradients by keyword.

Conversions

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

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

Use lerp, lerp+, mix, average, mixbox to mix two colors in different ways.

Distances

Several functions to calculate difference between colors, delta-E*-xxx etc.

References

• https://vis4.net/chromajs/
• https://github.com/thi-ng/color
• https://github.com/nschloe/colorio

achromatomaly clj

achromatopsia clj

adjust clj

(adjust col channel value)

(adjust col colorspace channel value)

Adjust (add) given value to a chosen channel. Works with any color space.

adjust-temperature clj

(adjust-temperature c temp)

(adjust-temperature c temp amount)

Adjust temperature of color.

Default amount: 0.35

See temperature and lerp+.

alpha clj

(alpha c)

Returns alpha value.

apply-theme clj

(apply-theme color color-theme)

Apply theme to the color, see color-themes for names.

Generates random color similar to provided one. All operations are done in LSH* color space (normalized to have values between 0 and 255).

Color theme can be one of:

• keyword - predefined color theme is used
• [L C H] - randomization scheme of given channel, which can be:
  • [min-value max-value] - uniform random value from given range
  • a number - [channel-value, channel+value] range is used for random selection
  • nil, or anything else - keep original channel value

average clj

(average cs)

(average cs colorspace)

Average colors in given colorspace (default: :sRGB)

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

black? clj

(black? c)

Check if color is black

blacken clj

(blacken col)

(blacken col amt)

Change color towards black.

Works in HSB color space. Default amount is set to 0.2 and changes B channel by this amount.

blue clj

(blue c)

Returns blue (third channel) value.

brighten clj

(brighten col)

(brighten col amt)

Change luma for givent color by given amount.

Works in LAB color space. Default amount is 1.0 and means change luma in LAB of 18.0.

See darken.

brightness clj

(brightness amount)

ch0 clj

(ch0 c)

Returns first channel value. Same as red.

ch1 clj

(ch1 c)

Returns second channel value. Same as green.

ch2 clj

(ch2 c)

Returns third channel value. Same as blue.

clamp clj

(clamp c)

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

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 gray. 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 function 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 individual maximum value.

color-themes clj

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 color spaces functions (normalized).

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

colorspaces-list clj

List of all color space names.

complementary clj

(complementary c)

(complementary c colorspace)

Create complementary color. Possible colorspaces are:

• :PalettonHSV (default)
• :HSB, :HSV, :HSL or :HWB
• :GLHS

contrast clj

(contrast amount)

contrast-ratio clj

(contrast-ratio c1 c2)

WCAG contrast ratio.

Based on YUV luma.

correct-luma clj

(correct-luma palette-or-gradient)

(correct-luma palette-or-gradient gradient-params)

Create palette or gradient with corrected luma to be linear.

See here

darken clj

(darken col)

(darken col amt)

Change luma for givent color by given amount.

Works in LAB color space. Default amount is 1.0 and means change luma in LAB of -18.0.

See brighten.

delta-c clj deprecated

delta-C* clj

(delta-C* c1 c2)

ΔC*_ab difference, chroma difference in LAB color space, CIE 1976

delta-C-RGB clj

(delta-C-RGB c1 c2)

ΔC in RGB color space

delta-D-HCL clj

(delta-D-HCL c1 c2)

Color difference in HCL (Sarifuddin and Missaou) color space

delta-E* clj

(delta-E* c1 c2)

ΔE*_ab difference, CIE 1976

delta-E*-2000 clj

(delta-E*-2000 c1 c2)

(delta-E*-2000 c1 c2 l c h)

ΔE* color difference, CIE 2000

http://www2.ece.rochester.edu/~gsharma/ciede2000/ciede2000noteCRNA.pdf

delta-E*-94 clj

(delta-E*-94 c1 c2)

ΔE* difference, CIE 1994

delta-E*-CMC clj

(delta-E*-CMC c1 c2)

(delta-E*-CMC c1 c2 l c)

ΔE* CMC difference

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

delta-E*-euclidean clj

(delta-E*-euclidean c1 c2)

(delta-E*-euclidean c1 c2 colorspace)

delta-e-cie clj deprecated

Delta E CIE distance (euclidean in LAB colorspace.

delta-e-cmc clj deprecated

delta-E-HyAB clj

(delta-E-HyAB c1 c2)

ΔE_HyAB difference

delta-e-jab clj deprecated

delta-E-z clj

(delta-E-z c1 c2)

ΔE* calculated in JAB color space.

delta-h clj deprecated

delta-H* clj

(delta-H* c1 c2)

ΔH* difference, hue difference in LAB, CIE 1976

desaturate clj

(desaturate col)

(desaturate col amt)

Change color saturation in LCH color space.

deuteranomaly clj

deuteranopia clj

exposure clj

(exposure amount)

fe-color-matrix clj

(fe-color-matrix [r1 r2 r3 r4 r5 g1 g2 g3 g4 g5 b1 b2 b3 b4 b5 a1 a2 a3 a4 a5])

Create a feColorMatrix operator.

find-gradient clj

find-palette clj

format-hex clj

(format-hex c)

Convert color to hex string (css).

When alpha is lower than 255.0, #rgba is returned.

from-CMY clj

CMY -> RGB

from-CMY* clj

CMY -> RGB, alias for from-CMY

from-Cubehelix clj

(from-Cubehelix c)

Cubehelix -> RGB

For ranges, see to-Cubehelix.

from-Cubehelix* clj

(from-Cubehelix* c)

Cubehelix -> RGB, normalized

from-DIN99 clj

DIN99 -> RGB

from-DIN99* clj

DIN99 -> RGB, normalized

from-DIN99b clj

DIN99b -> RGB

from-DIN99b* clj

DIN99b -> RGB, normalized

from-DIN99c clj

DIN99c -> RGB

from-DIN99c* clj

DIN99c -> RGB, normalized

from-DIN99d clj

DIN99d -> RGB

from-DIN99d* clj

DIN99d -> RGB, normalized

from-DIN99o clj

DIN99o -> RGB

from-DIN99o* clj

DIN99o -> RGB, normalized

from-GLHS clj

(from-GLHS c)

GLHS -> RGB

For ranges, see to-GLHS.

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, by Sarifuddin and Missaou.

For accepted ranges, see to-HCL.

from-HCL* clj

(from-HCL* c)

HCL -> RGB, normalized

from-HSB clj

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

from-HSB* clj

HSB(V) -> RGB (see from-HSV*)

from-HSI clj

(from-HSI c)

HSI -> RGB

For ranges, see to-HSI.

from-HSI* clj

HSI -> RGB, normalized

from-HSL clj

(from-HSL c)

HSL -> RGB

For ranges, see to-HSL.

from-HSL* clj

HSL -> RGB, normalized

from-HSV clj

(from-HSV c)

HSV -> RGB

Same as HSB.

For ranges, see to-HSV.

from-HSV* clj

HSV -> RGB, normalized

from-HunterLAB clj

(from-HunterLAB c)

HunterLAB -> RGB

For ranges, see to-HunterLAB

from-HunterLAB* clj

(from-HunterLAB* c)

HunterLAB -> RGB, normalized

from-HWB clj

(from-HWB c)

HWB -> RGB

For ranges, see to-HWB.

from-HWB* clj

HWB -> RGB, normalized

from-IgPgTg clj

(from-IgPgTg c)

IgPgTg -> RGB

from-IgPgTg* clj

(from-IgPgTg* c)

IgPgTg -> RGB, normalized

from-IPT clj

(from-IPT c)

IPT -> RGB

from-IPT* clj

(from-IPT* c)

IPT -> RGB, normalized

from-JAB clj

(from-JAB c)

JzAzBz -> RGB

For ranges, see to-JAB.

from-JAB* clj

(from-JAB* c)

JzAzBz -> RGB, normalized

from-JCH clj

(from-JCH c)

JCH -> RGB

For ranges, see to-JCH.

from-JCH* clj

(from-JCH* c)

JCH -> RGB, normalized

from-LAB clj

(from-LAB c)

LAB -> RGB,

For ranges, see to-LAB

from-LAB* clj

(from-LAB* c)

LAB -> RGB, normalized

from-LCH clj

(from-LCH c)

LCH -> RGB

For ranges, see to-LCH.

from-LCH* clj

(from-LCH* c)

LCH -> RGB, normalized

from-LCHuv clj

(from-LCHuv c)

LCHuv -> RGB

For ranges, see to-LCH.

from-LCHuv* clj

(from-LCHuv* c)

LCHuv -> RGB, normalized

from-linear clj

(from-linear v)

Gamma correction (gamma=1/2.4), lighten

from-linearRGB clj

linearRGB -> sRGB

from-linearRGB* clj

linearRGB -> sRGB

from-LMS clj

(from-LMS c)

LMS -> RGB, D65

Ranges: 0.0 - 100.0

from-LMS* clj

(from-LMS* c)

LMS -> RGB, normalized

from-luma-color-hue clj

(from-luma-color-hue from c)

For given color space convert from polar representation of the color

from-LUV clj

(from-LUV c)

LUV -> RGB

For ranges, see to-LUV

from-LUV* clj

(from-LUV* c)

LUV -> RGB, normalized

from-OHTA clj

(from-OHTA c)

OHTA -> RGB

For ranges, see to-OHTA.

from-OHTA* clj

(from-OHTA* c)

OHTA -> RGB, normalized

from-Okhsl clj

(from-Okhsl c)

Okhsl -> sRGB

from-Okhsl* clj

(from-Okhsl* c)

Okhsl -> sRGB, normalized

from-Okhsv clj

(from-Okhsv c)

Okhsv -> sRGB

from-Okhsv* clj

(from-Okhsv* c)

Okhsv -> sRGB, normalized

from-Okhwb clj

(from-Okhwb c)

Okhwb -> sRGB

from-Okhwb* clj

(from-Okhwb* c)

Okhwb -> sRGB, normalized

from-Oklab clj

(from-Oklab c)

Oklab -> RGB, see to-Oklab

from-Oklab* clj

(from-Oklab* c)

RGB -> Oklab, normalized

from-Oklch clj

(from-Oklch c)

Oklch -> RGB

from-Oklch* clj

(from-Oklch* c)

Oklch -> RGB, normalized

from-OSA clj

(from-OSA c)

RGB -> OSA-UCS

For ranges, see to-OSA.

from-OSA* clj

(from-OSA* c)

OSA-UCS -> RGB, normalized

Note that due to some extreme outliers, normalization is triple cubic power for g and j.

from-PalettonHSV clj

(from-PalettonHSV c)

from-PalettonHSV* clj

(from-PalettonHSV* c)

from-RGB clj

Alias for to-color

from-RGB* clj

Alias for to-color

from-RYB clj

(from-RYB c)

RYB -> RGB

from-RYB* clj

RYB -> RGB, normalized

from-sRGB clj

(from-sRGB c)

sRGB -> RGB

from-sRGB* clj

sRGB -> linear RGB

from-UCS clj

(from-UCS c)

UCS -> sRGB

from-UCS* clj

(from-UCS* c)

UCS -> sRGB, normalized

from-UVW clj

(from-UVW c)

UVW -> sRGB

from-UVW* clj

(from-UVW* c)

UVW -> sRGB, normalized

from-XYB clj

(from-XYB c)

XYB -> sRGB

from-XYB* clj

(from-XYB* c)

XYB -> sRGB, normalized

from-XYZ clj

(from-XYZ c)

XYZ -> sRGB

For ranges, see to-XYZ

from-XYZ* clj

(from-XYZ* c)

XYZ -> sRGB, normalized

from-XYZ1 clj

(from-XYZ1 c)

XYZ -> sRGB, from range 0-1

from-XYZ1* clj

XYZ -> sRGB, normalized

from-YCbCr clj

(from-YCbCr c)

YCbCr -> RGB

For ranges, see to-YCbCr.

from-YCbCr* clj

(from-YCbCr* c)

YCbCr -> RGB, normalized

from-YCgCo clj

(from-YCgCo c)

YCgCo -> RGB

For ranges, see to-YCgCo.

from-YCgCo* clj

(from-YCgCo* c)

YCgCo -> RGB, normalized

from-YDbDr clj

(from-YDbDr c)

YDbDr -> RGB

For ranges, see to-YDbDr.

from-YDbDr* clj

(from-YDbDr* c)

YDbDr -> RGB, normalized

from-YIQ clj

(from-YIQ c)

YIQ -> RGB

For ranges, see to-YIQ.

from-YIQ* clj

(from-YIQ* c)

YIQ -> RGB, normalized

from-YPbPr clj

(from-YPbPr c)

YPbPr -> RGB

For ranges, see to-YPbPr.

from-YPbPr* clj

(from-YPbPr* c)

YPbPr -> RGB, normalized

from-YUV clj

(from-YUV c)

YUV -> RGB

For ranges, see to-YUV.

from-YUV* clj

(from-YUV* c)

YUV -> RGB, normalized

from-Yxy clj

(from-Yxy c)

Yxy -> sRGB

For ranges, see to-Yxy.

from-Yxy* clj

(from-Yxy* c)

Yxy -> sRGB, normalized

get-channel clj

(get-channel col channel)

(get-channel col colorspace channel)

Get chosen channel. Works with any color space.

gradient clj

(gradient)

(gradient palette-or-gradient-name)

(gradient palette-or-gradient-name options)

Return gradient function.

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

Parameters;

• palette-or-gradient-name - name of the predefined gradient or palette (seq of colors).
• (optional) additional parameters map:
  • :colorspace - operate in given color space. Default: :RGB.
  • :interpolation - interpolation name or interpolation function. Interpolation can be one of [[interpolators-1d-list]] or [[easings-list]]. When easings is used, only first two colors are interpolated. Default: :linear-smile.
  • :to? - turn on/off conversion to given color space. Default: true.
  • :from? - turn on/off conversion from given color space. Default: true.
  • :domain - interpolation domain as seq of values for each color.

When called without parameters random gradient is returned.

gradient-cubehelix clj

Cubehelix gradient generator from two colors.

gray clj

(gray v)

(gray v a)

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

See also color

grayscale clj

(grayscale amount)

green clj

(green c)

Returns green (second channel) value.

hue clj

(hue c)

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

Uses hexagonal transformation. See also hue-polar.

hue-paletton clj

(hue-paletton c)

(hue-paletton r g b)

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

hue-polar clj

(hue-polar c)

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

Uses polar transformation. See also hue.

hue-rotate clj

(hue-rotate angle-degrees)

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.

lclamp clj

(lclamp c)

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

lerp clj

(lerp c1 c2)

(lerp c1 c2 t)

(lerp c1 c2 colorspace t)

Linear interpolation of two colors.

See also lerp+, lerp-, gradient and mix

lerp+ clj

(lerp+ c1 c2)

(lerp+ c1 c2 amount)

(lerp+ c1 c2 colorspace amount)

Linear interpolation of two colors conserving luma of the second color.

Amount: strength of the blend (defaults to 0.5).

See also lerp-.

lerp- clj

(lerp- c1 c2)

(lerp- c1 c2 amount)

(lerp- c1 c2 colorspace amount)

Linear interpolation of two colors conserving luma of the first color.

Amount: strength of the blend (defaults to 0.5)

See also lerp+.

luma clj

(luma c)

Returns luma

make-LCH clj

(make-LCH cs)

Create LCH conversion functions pair from any luma based color space.

merge-gradients clj

(merge-gradients g1 g2)

(merge-gradients g1 g2 midpoint)

Combine two gradients, optionally select midpoint (0.5 by default).

Resulting gradient has colors from g1 for values lower than midpoint and from g2 for values higher than midpoint

mix clj

(mix c1 c2)

(mix c1 c2 t)

(mix c1 c2 colorspace t)

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

chroma.js way

mixbox clj

(mixbox col1 col2)

(mixbox col1 col2 t)

Pigment based color mixing.

https://github.com/scrtwpns/mixbox

mixsub clj

(mixsub c1 c2)

(mixsub c1 c2 t)

(mixsub c1 c2 colorspace t)

Subtractive color mix in given optional colorspace (default: :RGB) and optional ratio (default: 0.5)

modulate clj

(modulate col channel amount)

(modulate col colorspace channel amount)

Modulate (multiply) chosen channel by given amount. Works with any color space.

named-colors-list clj

(named-colors-list)

Return list of the named colors.

nearest-color clj

(nearest-color pal)

(nearest-color pal c)

(nearest-color pal c dist-fn)

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

negate clj

(negate c)

(negate c alpha?)

Negate color (subract from 255.0)

not-black? clj

(not-black? c)

Check if color is not black

noticable-different? clj

(noticable-different? c1 c2)

(noticable-different? c1 c2 s p)

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

p25_7 clj

pack clj

(pack c)

Pack color to ARGB 32bit integer.

palette clj

(palette)

(palette p)

(palette p number-of-colors)

(palette p number-of-colors gradient-params)

Get palette.

If argument is a keyword, returns one from palette presets. If argument is a number, returns one from colourlovers palettes. If argument is a gradient, returns 5 or number-of-colors samples.

If called without argument, random palette is returned

Optionally you can pass number of requested colors and other parameters as in resample

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 hue-paletton 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

possible-color? clj

(possible-color? c)

Check if given argument can be considered as color.

Check is done by analyzing type of the argument.

See also valid-color?.

possible-palette? clj

(possible-palette? c)

Check if given argument can be considered as palette.

Check is done by analyzing type of the argument.

protanomaly clj

protanopia clj

quil clj

Convert color to quil color type (ie. ARGB Integer). Alias to pack.

r30 clj

r6 clj

r63 clj

random-color clj

(random-color)

(random-color alpha-or-color-theme)

(random-color color-theme alpha)

Generate random color.

Optionally color theme or alpha can be provided.

List of possible color themes is stored in color-themes var. These are taken from thi.ng and paletton.

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.

red clj

(red c)

Returns red (first channel) value.

reduce-colors clj

(reduce-colors xs number-of-colors)

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

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

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

relative-luma clj

(relative-luma c)

Returns relative luminance

resample clj

(resample pal number-of-colors)

(resample pal number-of-colors 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.

saturate clj

(saturate col)

(saturate col amt)

Change color saturation in LCH color space.

saturation clj

(saturation amount)

scale clj

(scale c v)

(scale c v alpha?)

Multiply color channels by given value, do not change alpha channel by default

scale-down clj

(scale-down c)

(scale-down c alpha?)

Divide color channels by 255.0

scale-up clj

(scale-up c)

(scale-up c alpha?)

Multiply color channels by 255.0

sepia clj

(sepia amount)

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-blue clj

(set-blue c val)

Set blue channel and return new color

set-ch0 clj

(set-ch0 c val)

Set red channel and return new color.

set-ch1 clj

(set-ch1 c val)

Set green channel and return new color.

set-ch2 clj

(set-ch2 c val)

Set blue channel and return new color

set-channel clj

(set-channel col channel val)

(set-channel col colorspace channel val)

Set chosen channel with given value. Works with any color space.

set-green clj

(set-green c val)

Set green channel and return new color.

set-red clj

(set-red c val)

Set red channel and return new color.

temperature clj

(temperature t)

Color representing given black body temperature t in Kelvins (or name as keyword).

Reference: CIE 1964 10 degree CMFs

Using improved interpolation functions.

Possible temperature names: :candle, :sunrise, :sunset, :lightbulb, :morning, :moonlight, :midday, :cloudy-sky, :blue-sky, :warm, :cool, :white, :sunlight

temperature-names clj

thing-presets-list clj

tinter clj

(tinter tint-color)

Creates fn to tint color using other color(s).

tint-color

to-awt-color clj

(to-awt-color c)

Convert any color representation to java.awt.Color.

to-CMY clj

(to-CMY c)

RGB -> CMY

to-CMY* clj

CMY -> RGB, alias for to-CMY

to-color clj

(to-color c)

Convert any color representation to Vec4 vector.

to-Cubehelix clj

(to-Cubehelix c)

RGB -> Cubehelix

D3 version

Ranges:

• H: 0.0 - 360.0
• S: 0.0 - 4.61
• L: 0.0 - 1.0

to-Cubehelix* clj

(to-Cubehelix* c)

RGB -> Cubehelix, normalized

to-DIN99 clj

RGB -> DIN99

to-DIN99* clj

RGB -> DIN99, normalized

to-DIN99b clj

RGB -> DIN99

to-DIN99b* clj

RGB -> DIN99b, normalized

to-DIN99c clj

RGB -> DIN99

to-DIN99c* clj

RGB -> DIN99c, normalized

to-DIN99d clj

RGB -> DIN99

to-DIN99d* clj

RGB -> DIN99d, normalized

to-DIN99o clj

RGB -> DIN99

to-DIN99o* clj

RGB -> DIN99o, normalized

to-GLHS clj

(to-GLHS c)

RGB -> GLHS

Color Theory and Modeling for Computer Graphics, Visualization, and Multimedia Applications (The Springer International Series in Engineering and Computer Science) by Haim Levkowitz

Weights: 0.2 (min), 0.1 (mid), 0.7 (max).

Ranges:

• L: 0.0 - 1.0
• H: 0.0 - 360.0
• S: 0.0 - 1.0

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, by Sarifuddin and Missaou.

lambda = 3.0

Returned ranges:

• H: -180.0 - 180.0
• C: 0.0 - 170.0
• L: 0.0 - 135.266

to-HCL* clj

(to-HCL* c)

RGB -> HCL, normalized

to-HSB clj

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

to-HSB* clj

RGB -> HSB(V) (see to-HSV*)

to-HSI clj

(to-HSI c)

RGB -> HSI

Ranges:

• H: 0.0 - 360
• S: 0.0 - 1.0
• I: 0.0 - 1.0

to-HSI* clj

RGB -> HSI, normalized

to-HSL clj

(to-HSL c)

RGB -> HSL

Ranges:

• H: 0.0 - 360
• S: 0.0 - 1.0
• L: 0.0 - 1.0

to-HSL* clj

RGB -> HSL, normalized

to-HSV clj

(to-HSV c)

RGB -> HSV

Ranges:

• H: 0.0 - 360
• S: 0.0 - 1.0
• V: 0.0 - 1.0

to-HSV* clj

RGB -> HSV, normalized

to-HunterLAB clj

(to-HunterLAB c)

RGB -> HunterLAB

Returned ranges:

• L: 0.0 - 100.0
• a: -69.08 - 109.48
• b: -199.78 - 55.72

to-HunterLAB* clj

(to-HunterLAB* c)

RGB -> HunterLAB, normalized

to-HWB clj

(to-HWB c)

RGB -> HWB

HWB - A More Intuitive Hue-Based Color Model by Alvy Ray Smitch and Eric Ray Lyons, 1995-1996

Ranges:

• H: 0.0 - 360.0
• W: 0.0 - 1.0
• B: 0.0 - 1.0

to-HWB* clj

RGB -> HWB, normalized

to-IgPgTg clj

(to-IgPgTg c)

RGB -> IgPgTg

Ranges:

• Ig: 0.0 - 0.97
• Pg: -0.35 - 0.39
• Tg: -0.41 - 0.44

to-IgPgTg* clj

(to-IgPgTg* c)

RGB -> IgPgTg*, normalized

to-IPT clj

(to-IPT c)

RGB -> IPT

Ranges:

• I: 0.0 - 1.0
• P: -0.45 - 0.66
• T: -0.75 - 0.65

to-IPT* clj

(to-IPT* c)

RGB -> IPT, normalized

to-JAB clj

(to-JAB c)

RGB -> JzAzBz

Jab https://www.osapublishing.org/oe/abstract.cfm?uri=oe-25-13-15131

Ranges:

• J: 0.0 - 0.17
• a: -0.09 - 0.11
• b: -0.156 - 0.115

Reference white point set to 100.0

to-JAB* clj

(to-JAB* c)

RGB -> JzAzBz, normalized

to-JCH clj

(to-JCH c)

RGB -> JCH

Hue based color space derived from JAB

Ranges:

• J: 0.0 - 0.167
• C: 0.0 - 0.159
• H: 0.0 - 360.0

to-JCH* clj

(to-JCH* c)

RGB -> JCH, normalized

to-LAB clj

(to-LAB c)

RGB -> LAB

Returned ranges:

• L: 0.0 - 100.0
• a: -86.18 - 98.25
• b: -107.86 - 94.48

to-LAB* clj

(to-LAB* c)

RGB -> LAB, normalized

to-LCH clj

(to-LCH c)

RGB -> LCH

Returned ranges:

• L: 0.0 - 100.0
• C: 0.0 - 133.82
• H: 0.0 - 360.0

to-LCH* clj

(to-LCH* c)

RGB -> LCH, normalized

to-LCHuv clj

(to-LCHuv c)

RGB -> LCHuv

Returned ranges:

• L: 0.0 - 100.0
• C: 0.0 - 180.0
• H: 0.0 - 360.0

to-LCHuv* clj

(to-LCHuv* c)

RGB -> LCHuv, normalized

to-linear clj

(to-linear v)

Gamma correction (gamma=2.4), darken

to-linearRGB clj

sRGB -> linearRGB

to-linearRGB* clj

sRGB -> linearRGB

to-LMS clj

(to-LMS c)

RGB -> LMS, D65

Ranges: 0.0 - 100.0

to-LMS* clj

(to-LMS* c)

RGB -> LMS, normalized

to-luma-color-hue clj

(to-luma-color-hue to c)

For given color space return polar representation of the color

to-LUV clj

(to-LUV c)

RGB -> LUV

Returned ranges:

• L: 0.0 - 100.0
• u: -83.08 - 175.05
• v: -134.12 - 107.40

to-LUV* clj

(to-LUV* c)

RGB -> LUV, normalized

to-OHTA clj

(to-OHTA c)

RGB -> OHTA

Returned ranges:

• I1: 0.0 - 255.0
• I2: -127.5 - 127.5
• I3: -127.5 - 127.5

to-OHTA* clj

(to-OHTA* c)

RGB -> OHTA, normalized

to-Okhsl clj

(to-Okhsl c)

sRGB -> Okhsl

Ranges:

• h: 0.0 - 1.0
• s: 0.0 - 1.0
• l: 0.0 - 1.0

to-Okhsl* clj

(to-Okhsl* c)

RGB -> Okhsl, normalized

to-Okhsv clj

(to-Okhsv c)

sRGB -> Okhsv

Ranges:

• h: 0.0 - 1.0
• s: 0.0 - 1.0
• v: 0.0 - 1.0

to-Okhsv* clj

(to-Okhsv* c)

RGB -> Okhsv, normalized

to-Okhwb clj

(to-Okhwb c)

sRGB -> Okhwb

Ranges:

• h: 0.0 - 1.0
• w: 0.0 - 1.0
• b: 0.0 - 1.0

to-Okhwb* clj

(to-Okhwb* c)

RGB -> Okhwb, normalized

to-Oklab clj

(to-Oklab c)

RGB -> Oklab

https://bottosson.github.io/posts/oklab/

• L: 0.0 - 1.0
• a: -0.234 - 0.276
• b: -0.312 - 0.199

to-Oklab* clj

(to-Oklab* c)

RGB -> Oklab, normalized

to-Oklch clj

(to-Oklch c)

RGB -> Oklch

to-Oklch* clj

(to-Oklch* c)

RGB -> Oklch, normalized

to-OSA clj

(to-OSA c)

OSA-UCS -> RGB

https://github.com/nschloe/colorio/blob/master/colorio/_osa.py

Ranges:

• L: -13.5 - 7.14
• j (around): -20.0 - 14.0 + some extreme values
• g (around): -20.0 - 12.0 + some extreme values

Note that for some cases (like (to-OSA [18 7 4])) function returns some extreme values.

to-OSA* clj

(to-OSA* c)

OSA-UCS -> RGB, normalized

Note that due to some extreme outliers, normalization is triple cubic root for g and j.

to-PalettonHSV clj

(to-PalettonHSV c)

to-PalettonHSV* clj

(to-PalettonHSV* c)

to-RGB clj

Alias for to-color

to-RGB* clj

Alias for to-color

to-RYB clj

(to-RYB c)

RGB -> RYB

to-RYB* clj

RGB -> RYB, normalized

to-sRGB clj

(to-sRGB c)

RGB -> sRGB

to-sRGB* clj

linear RGB -> sRGB

to-UCS clj

(to-UCS c)

sRGB -> UCS

• U: 0.0 - 0.63
• V: 0.0 - 1.0
• W: 0.0 - 1.57

to-UCS* clj

(to-UCS* c)

sRGB -> UCS, normalized

to-UVW clj

(to-UVW c)

sRGB -> UVW

• U: -82.15 171.81
• V: -87.16 70.82
• W: -17.0 99.0

to-UVW* clj

(to-UVW* c)

sRGB -> UVW, normalized

to-XYB clj

(to-XYB c)

sRGB -> XYB

• X: -0.015386116472573375 - 0.02810008316127735
• Y: 0.0 - 0.8453085619621623
• Z: 0.0 - 0.8453085619621623

to-XYB* clj

(to-XYB* c)

sRGB -> XYB, normalized

to-XYZ clj

(to-XYZ c)

sRGB -> XYZ

Returned ranges (D65):

• X: 0.0 - 95.047
• Y: 0.0 - 100.0
• Z: 0.0 - 108.883

to-XYZ* clj

(to-XYZ* c)

sRGB -> XYZ, normalized

to-XYZ1 clj

(to-XYZ1 c)

sRGB -> XYZ, scaled to range 0-1

to-XYZ1* clj

sRGB -> XYZ, normalized

to-YCbCr clj

(to-YCbCr c)

RGB -> YCbCr

Used in JPEG. BT-601

Ranges;

• Y: 0.0 - 255.0
• Cb: -127.5 - 127.5
• Cr: -127.5 - 127.5

to-YCbCr* clj

(to-YCbCr* c)

RGB -> YCbCr, normalized

to-YCgCo clj

(to-YCgCo c)

RGB -> YCgCo

Ranges:

• Y: 0.0 - 255.0
• Cg: -127.5 - 127.5
• Co: -127.5 - 127.5

to-YCgCo* clj

(to-YCgCo* c)

RGB -> YCgCo, normalized

to-YDbDr clj

(to-YDbDr c)

RGB -> YDbDr

Ranges:

• Y: 0.0 - 255.0
• Db: -340.0 - 340.0
• Dr: -340.0 - 340.0

to-YDbDr* clj

(to-YDbDr* c)

RGB -> YDbDr

to-YIQ clj

(to-YIQ c)

RGB -> YIQ

Ranges:

• Y: 0.0 - 255.0
• I: -151.9 - 151.9
• Q: -133.26 - 133.26

to-YIQ* clj

(to-YIQ* c)

RGB -> YIQ, normalized

to-YPbPr clj

(to-YPbPr c)

RGB -> YPbPr

Ranges:

• Y: 0.0 - 255.0
• Pb: -236.6 - 236.6
• Pr: -200.8 - 200.8

to-YPbPr* clj

(to-YPbPr* c)

RGB -> YPbPr, normalized

to-YUV clj

(to-YUV c)

RGB -> YUV

Ranges:

• Y: 0.0 - 255.0
• u: -111.2 - 111.2
• v: -156.8 - 156.8

to-YUV* clj

(to-YUV* c)

RGB -> YUV, normalized

to-Yxy clj

(to-Yxy c)

sRGB -> Yxy

Returned ranges:

• Y: 0.0 - 100.0
• x: 0.15 - 0.64
• y: 0.06 - 0.60

to-Yxy* clj

(to-Yxy* c)

sRGB -> Yxy, normalized

tritanomaly clj

tritanopia clj

valid-color? clj

(valid-color? c)

Check if given argument is valid color.

Check is done by trying to convert to color representation.

Returns color when valid.

See also possible-color?

wavelength clj

(wavelength lambda)

Returns color from given wavelength in nm

weighted-average clj

(weighted-average cs weights)

(weighted-average cs weights colorspace)

Average colors with weights in given colorspace (default: :sRGB)

whiten clj

(whiten col)

(whiten col amt)

Change color towards white.

Works in HSB color space. Default amount is set to 0.2 and changes W channel by this amount.

See blacken.