Coverage report

module Chroma.Blend exposing (blend, BlendMode(..))

{-| [Blend Modes](https://en.wikipedia.org/wiki/Blend_modes) define how to combine two layers.


# Definition

@docs blend, BlendMode

-}

import Chroma.Converter.Out.ToRgba as ToRgba
import Chroma.Ops.Alpha as OpsAlpha
import Chroma.Types as Types
import Color


{-| TBD
-}
type BlendMode
= Normal
| Multiply
| Darken
| Lighten
| Screen
| Overlay
| Burn
| Dodge
| Exclusion


{-| TBD
-}
blend : BlendMode -> Types.ExtColor -> Types.ExtColor -> Types.ExtColor
blend mode colorExt1 colorExt2 =
let
color1 =
ToRgba.toRgba colorExt1

color2 =
ToRgba.toRgba colorExt2

newAlpha =
color2.alpha + color1.alpha * (1 - color2.alpha)

newColor c1 c2 =
Color.rgb (colorF c1.red c2.red) (colorF c1.green c2.green) (colorF c1.blue c2.blue) |> Types.RGBAColor |> OpsAlpha.setAlpha newAlpha

colorF a b =
f a b |> clamp 0 1

f =
case mode of
Normal ->
\a _ -> a

Multiply ->
(*)

Darken ->
\a b ->
if a > b then
b

else
a

Lighten ->
\a b ->
if a > b then
a

else
b

Screen ->
\a b ->
a + b - a * b

Overlay ->
\a b ->
if a <= 0.5 then
2 * a * b

else
1 - (2 * (1 - a)) * (1 - b)

Burn ->
\a b ->
1 - (1 - b) / a

Dodge ->
\a b ->
if a == 1 then
1

else
b / (1 - a)

Exclusion ->
\a b ->
a + b - (2 * a * b)
in
newColor color1 color2

module Chroma.Chroma exposing
( chroma, name, mix, mixChroma, average, averageChroma, blend, blendChroma, contrast, contrastChroma, distance, distance255, limits
, scale, scaleF, colors, colorsF, domain, domainF, classes, padding, paddingBoth
, scaleDefault, scaleWith, colorsWith, domainWith, classesWithArray, paddingWith, paddingBothWith
)

{-| The attempt here is to provide something similar to [Chroma.js](https://gka.github.io/chroma.js/) but also
has more features and is idiomatic Elm.


# Color

@docs chroma, name, mix, mixChroma, average, averageChroma, blend, blendChroma, contrast, contrastChroma, distance, distance255, limits


# Color Scales

@docs scale, scaleF, colors, colorsF, domain, domainF, classes, padding, paddingBoth


# Color Scales Helpers

@docs scaleDefault, scaleWith, colorsWith, domainWith, classesWithArray, paddingWith, paddingBothWith

-}

import Chroma.Blend as Blend
import Chroma.Colors.W3CX11 as W3CX11
import Chroma.Converter.In.Hex2Rgb as Hex2Rgb
import Chroma.Converter.Misc.ColorSpace as ColorSpace
import Chroma.Converter.Out.ToHex as ToHex
import Chroma.Converter.Out.ToRgba as ToRgba
import Chroma.Interpolator as Interpolator
import Chroma.Limits.Limits as Limits
import Chroma.Ops.Luminance as Luminance
import Chroma.Ops.Numeric as Numeric
import Chroma.Scale as Scale
import Chroma.Types as Types
import Color
import List.Nonempty as Nonempty
import Result


{-| Given a valid hex string (8, 6 or 3) or [`W3CX11 Color`][w3cx11] name and produce an RGB Color.

Chroma.chroma "magenta"
--> Ok (RGBAColor (RgbaSpace 1 0 1 1)) : Result String Types.ExtColor

Chroma.chroma "#c0c0c0"
--> Ok (RGBAColor (RgbaSpace 0.7529411764705882 0.7529411764705882 0.7529411764705882 1)) : Result String Types.ExtColor

[w3cx11]: Chroma-Colors-W3CX11

-}
chroma : String -> Result String Types.ExtColor
chroma colorName =
case W3CX11.named colorName of
Ok value ->
Ok (Types.RGBAColor value)

Err _ ->
Hex2Rgb.hex2rgb colorName |> Result.map Types.RGBAColor


{-| Given a color turn it into a [`W3CX11 Color`][w3cx11] name or fall back to an RGB string.

Types.RGBAColor (Color.rgb255 255 0 255) |> Chroma.name
--> Ok "magenta" : Result String String

[w3cx11]: Chroma-Colors-W3CX11

-}
name : Types.ExtColor -> Result String String
name ext =
let
{ red, green, blue } =
ToRgba.toRgba255 ext

rgb255 =
Color.rgb255 red green blue
in
case W3CX11.color rgb255 of
Ok value ->
Ok value

Err _ ->
Ok (ToHex.toHex ext)


{-| Mix two colors, first converting them to the same color space and then interpolate them with the given ratio.

Chroma.mix Types.RGBA 0.25 (Types.RGBAColor W3CX11.red) (Types.RGBAColor W3CX11.blue)
--> RGBAColor (RgbaSpace 0.75 0 0.25 1) : Types.ExtColor

-}
mix : Types.Mode -> Float -> Types.ExtColor -> Types.ExtColor -> Types.ExtColor
mix mode f color1 color2 =
let
convert =
ColorSpace.colorConvert mode
in
Interpolator.interpolate (convert color1) (convert color2) f


{-| Mix two colors defined as a string, first converting them to the same color space mode and then interpolate
with the given ratio.

Chroma.mixChroma Types.RGBA 0.25 "red" "blue"
--> Ok (RGBAColor (RgbaSpace 0.75 0 0.25 1)) : Result String Types.ExtColor

-}
mixChroma : Types.Mode -> Float -> String -> String -> Result String Types.ExtColor
mixChroma mode f color1 color2 =
Result.map2 (mix mode f) (chroma color1) (chroma color2)


{-| Find the average of a non-empty list of colors, first converting them to the same color space.

Only supports RGBA, CYMK and LAB.

Chroma.average Types.RGBA (Nonempty.Nonempty (Types.RGBAColor W3CX11.red) [(Types.RGBAColor W3CX11.blue)])
--> Ok (RGBAColor (RgbaSpace 0.5 0 0.5 1)) : Result String Types.ExtColor

-}
average : Types.Mode -> Nonempty.Nonempty Types.ExtColor -> Result String Types.ExtColor
average mode extList =
let
calcAverage =
case mode of
Types.RGBA ->
Ok result

Types.CMYK ->
Ok result

Types.LAB ->
Ok result

_ ->
Err "Mode not supported"

result =
Nonempty.map (ColorSpace.colorConvert mode) extList |> ColorSpace.rollingAverage
in
calcAverage


{-| Find the average of a non-empty list of colors defined as strings, first converting them to the same color space.

Only supports RGBA, CYMK and LAB.

Chroma.averageChroma Types.RGBA (Nonempty.Nonempty "red" ["blue"])
--> Ok (RGBAColor (RgbaSpace 0.5 0 0.5 1)) : Result String Types.ExtColor

-}
averageChroma : Types.Mode -> Nonempty.Nonempty String -> Result String Types.ExtColor
averageChroma mode strList =
Nonempty.map chroma strList |> ColorSpace.combine |> Result.andThen (average mode)


{-| Combine two colors using the given blend modes.

Chroma.blend Blend.Burn (Types.RGBAColor W3CX11.red) (Types.RGBAColor W3CX11.blue)
--> RGBAColor (RgbaSpace 0 0 1 1) : Types.ExtColor

-}
blend : Blend.BlendMode -> Types.ExtColor -> Types.ExtColor -> Types.ExtColor
blend mode color1 color2 =
Blend.blend mode color1 color2


{-| Combine two colors, defined as strings, using the given blend modes.

Chroma.blendChroma Blend.Darken "cyan" "magenta"
--> Ok (RGBAColor (RgbaSpace 0 0 1 1)) : Result String Types.ExtColor

-}
blendChroma : Blend.BlendMode -> String -> String -> Result String Types.ExtColor
blendChroma mode strColor1 strColor2 =
Result.map2 (Blend.blend mode) (chroma strColor1) (chroma strColor2)


{-| [`WCGA contrast`](https://www.w3.org/TR/WCAG20-TECHS/) ratio between two colors.

Chroma.contrast (Types.RGBAColor W3CX11.pink) (Types.RGBAColor W3CX11.hotpink)
--> 1.7214765344592284 : Float

-}
contrast : Types.ExtColor -> Types.ExtColor -> Float
contrast color1 color2 =
Luminance.contrast color1 color2


{-| [`WCGA contrast`](https://www.w3.org/TR/WCAG20-TECHS/) ratio between two colors.

Chroma.contrastChroma "pink" "hotpink"
--> Ok 1.7214765344592284 : Result String Float

-}
contrastChroma : String -> String -> Result String Float
contrastChroma strColor1 strColor2 =
Result.map2 Luminance.contrast (chroma strColor1) (chroma strColor2)


{-| Calculate the distance in RGB 255 color space.

Chroma.distance255 (Types.RGBAColor W3CX11.red) (Types.RGBAColor W3CX11.blue)
--> 360.62445840513925 : Float

-}
distance255 : Types.ExtColor -> Types.ExtColor -> Float
distance255 color1 color2 =
let
fstColor255 =
ColorSpace.colorConvert Types.RGBA color1 |> ColorSpace.toNonEmptyList |> Nonempty.map (\x -> x * 255)

sndColor255 =
ColorSpace.colorConvert Types.RGBA color2 |> ColorSpace.toNonEmptyList |> Nonempty.map (\x -> x * 255)
in
Numeric.calcDistance fstColor255 sndColor255


{-| Calculate the distance for a given color space.

Chroma.distance Types.RGBA (Types.RGBAColor W3CX11.red) (Types.RGBAColor W3CX11.blue)
--> 1.4142135623730951 : Float

-}
distance : Types.Mode -> Types.ExtColor -> Types.ExtColor -> Float
distance mode color1 color2 =
let
aColor1 =
ColorSpace.colorConvert mode color1 |> ColorSpace.toNonEmptyList

aColor2 =
ColorSpace.colorConvert mode color2 |> ColorSpace.toNonEmptyList
in
Numeric.calcDistance aColor1 aColor2


{-| Create breaks/classes based on the data given.

Supports: CkMeans (a variant of kmeans), Equal, Head/Tail, Jenks, Logarithmic, and Quantile.

Chroma.limits Limits.Equal 5 (Nonempty.Nonempty 0 [ 10 ])
--> Nonempty 0 [2,4,6,8,10] : Nonempty.Nonempty Float

Chroma.limits Limits.CkMeans 3 (Nonempty.Nonempty 1 [ 2, 1, 4, 3, 5, 2, 5, 4 ])
--> Nonempty 1 [2,4] : Nonempty.Nonempty Float

-}
limits : Limits.LimitMode -> Int -> Nonempty.Nonempty Float -> Nonempty.Nonempty Float
limits mode bins data =
Limits.limits mode bins data


{-| Return a configuration and a function from a float to a color based on the default values - colors White to Black,
domain 0 - 1.
-}
scaleDefault : ( Scale.Data, Float -> Types.ExtColor )
scaleDefault =
scale Scale.defaultColorList


{-| Return a configuration and a function from a float to a color based on default values and a list of colors.
-}
scale : Nonempty.Nonempty Types.ExtColor -> ( Scale.Data, Float -> Types.ExtColor )
scale colorsList =
scaleWith (Scale.createDiscreteColorData colorsList Scale.defaultSharedData)


{-| Return a configuration and a function from a float to a color based on default values and a function given a
value from 0 -> 1 produces a new color.
-}
scaleF : (Float -> Types.ExtColor) -> ( Scale.Data, Float -> Types.ExtColor )
scaleF colorFunction =
scaleWith (Scale.createContinuousColorData colorFunction Scale.defaultSharedData)


{-| Return a new configuration and a function from a float to a color based on the given configuration values and
the given colors.
-}
scaleWith : Scale.Data -> ( Scale.Data, Float -> Types.ExtColor )
scaleWith data =
let
newData =
Scale.initSharedData data
in
( newData, Scale.getColor newData )


{-| Return a new configuration and a function from a float to a color using the default configuration, the given
colors and the total number of colors (bins) to return.
-}
classes : Int -> Scale.Data -> ( Scale.Data, Float -> Types.ExtColor )
classes bins data =
let
newSharedDataWithClasses =
let
newData =
Scale.initSharedData data

newSharedData =
newData.shared

newDomainValues =
newSharedData.domainValues

d =
Nonempty.Nonempty (Tuple.first newDomainValues) [ Tuple.second newDomainValues ]
in
if bins == 0 then
{ newSharedData | classes = Just d }

else
{ newSharedData | classes = Just (limits Limits.Equal bins d) }

updatedData =
{ data | shared = newSharedDataWithClasses }
in
( updatedData, Scale.getColor updatedData )


{-| Return a new configuration and a function from a float to a color based on the given configuration values, the given
colors and a predefined set of breaks/classes.
-}
classesWithArray : Nonempty.Nonempty Float -> Scale.Data -> ( Scale.Data, Float -> Types.ExtColor )
classesWithArray newClasses data =
let
oldShared =
data.shared

matchNewClassesInShared =
{ oldShared | classes = Just newClasses }

setDomainInData =
{ data | shared = matchNewClassesInShared } |> Scale.domain newClasses

newData =
Scale.initSharedData setDomainInData
in
( newData, Scale.getColor newData )


{-| Return a new configuration and a function from a float to a color based on a new domain and list of colors.
The list of colors must be the same length as the domain or only the first and last values will be used.
-}
domain : Nonempty.Nonempty Float -> Nonempty.Nonempty Types.ExtColor -> ( Scale.Data, Float -> Types.ExtColor )
domain newDomain colorsList =
let
newData =
Scale.createDiscreteColorData colorsList Scale.defaultSharedData |> Scale.domain newDomain
in
( newData, Scale.getColor newData )


{-| Return a new configuration and a function from a float to a color based on a new domain and a function given a
value from 0 -> 1 produces a new color.
-}
domainF : Nonempty.Nonempty Float -> (Float -> Types.ExtColor) -> ( Scale.Data, Float -> Types.ExtColor )
domainF newDomain colorFunction =
let
newData =
Scale.createContinuousColorData colorFunction Scale.defaultSharedData |> Scale.domain newDomain
in
( newData, Scale.getColor newData )


{-| Return a new configuration and a function from a float to a color based on an existing configuration and a new
domain. If using a list of colors, they must be the same length as the domain or only the first and last values will
be used.
-}
domainWith : Scale.Data -> Nonempty.Nonempty Float -> ( Scale.Data, Float -> Types.ExtColor )
domainWith data newDomain =
let
newData =
Scale.initSharedData data |> Scale.domain newDomain
in
( newData, Scale.getColor newData )


{-| Remove a fraction of the color gradient (0 -> 1). Applies to both sides equally.
-}
padding : Float -> Nonempty.Nonempty Types.ExtColor -> ( Scale.Data, Float -> Types.ExtColor )
padding both colorsList =
paddingBoth ( both, both ) colorsList


{-| Remove a fraction of the color gradient (0 -> 1).
-}
paddingBoth : ( Float, Float ) -> Nonempty.Nonempty Types.ExtColor -> ( Scale.Data, Float -> Types.ExtColor )
paddingBoth ( newLeft, newRight ) colorsList =
let
newData =
Scale.createDiscreteColorData colorsList Scale.defaultSharedData
in
paddingBothWith newData ( newLeft, newRight )


{-| Remove a fraction of the color gradient (0 -> 1). Applies both sides equally.
-}
paddingWith : Scale.Data -> Float -> ( Scale.Data, Float -> Types.ExtColor )
paddingWith data both =
paddingBothWith data ( both, both )


{-| Remove a fraction of the color gradient (0 -> 1).
-}
paddingBothWith : Scale.Data -> ( Float, Float ) -> ( Scale.Data, Float -> Types.ExtColor )
paddingBothWith data ( newLeft, newRight ) =
let
oldShared =
data.shared

newShared =
{ oldShared | paddingValues = ( newLeft, newRight ) }

newData =
{ data | shared = newShared }
in
scaleWith newData


{-| Return a configuration and a list of colors based on the number of equal distance buckets to create and a
list of colors.
-}
colors : Int -> Nonempty.Nonempty Types.ExtColor -> ( Scale.Data, Nonempty.Nonempty Types.ExtColor )
colors i colorsList =
let
newData =
Scale.createDiscreteColorData colorsList Scale.defaultSharedData
in
colorsWith newData i


{-| Return a configuration and a list of colors based on the number of equal distance buckets to create
and a function given a value from 0 -> 1 produces a new color.
-}
colorsF : Int -> (Float -> Types.ExtColor) -> ( Scale.Data, Nonempty.Nonempty Types.ExtColor )
colorsF i colorFunction =
let
newData =
Scale.createContinuousColorData colorFunction Scale.defaultSharedData
in
colorsWith newData i


{-| Return the data with the given colors and a new list of colors.
-}
colorsWith : Scale.Data -> Int -> ( Scale.Data, Nonempty.Nonempty Types.ExtColor )
colorsWith data i =
( data, Scale.colors i data )

module Chroma.Colors.Brewer exposing
( buGn, buPu, gnBu, orRd, puBu, puBuGn, puRd, rdPu, ylGn, ylGnBu, ylOrBr, ylOrRd
, blues, greens, greys, oranges, purples, reds
, brBG, piYG, pRGn, puOr, rdBu, rdGy, rdYlBu, rdYlGn, spectral
, accent, dark2, paired, pastel1, pastel2, set1, set2, set3
)

{-| [Colorbrewer 2.0 Colors](http://colorbrewer2.org/)


# Sequential Multi-hue Color Map

@docs buGn, buPu, gnBu, orRd, puBu, puBuGn, puRd, rdPu, ylGn, ylGnBu, ylOrBr, ylOrRd


# Sequential Single Color Map

@docs blues, greens, greys, oranges, purples, reds


# Diverging Color Ramp

@docs brBG, piYG, pRGn, puOr, rdBu, rdGy, rdYlBu, rdYlGn, spectral


# Qualitative Color Ramp

@docs accent, dark2, paired, pastel1, pastel2, set1, set2, set3

-}

import Color exposing (Color, rgb255)
import List.Nonempty as Nonempty



-- Sequential Multi-Hue


{-| TBD
-}
buGn : Nonempty.Nonempty Color
buGn =
Nonempty.Nonempty (rgb255 247 252 253) [ rgb255 229 245 249, rgb255 204 236 230, rgb255 153 216 201, rgb255 102 194 164, rgb255 65 174 118, rgb255 35 139 69, rgb255 0 109 44, rgb255 0 68 27 ]


{-| TBD
-}
buPu : Nonempty.Nonempty Color
buPu =
Nonempty.Nonempty (rgb255 247 252 253) [ rgb255 224 236 244, rgb255 191 211 230, rgb255 158 188 218, rgb255 140 150 198, rgb255 140 107 177, rgb255 136 65 157, rgb255 129 15 124, rgb255 77 0 75 ]


{-| TBD
-}
gnBu : Nonempty.Nonempty Color
gnBu =
Nonempty.Nonempty (rgb255 247 252 240) [ rgb255 224 243 219, rgb255 204 235 197, rgb255 168 221 181, rgb255 123 204 196, rgb255 78 179 211, rgb255 43 140 190, rgb255 8 104 172, rgb255 8 64 129 ]


{-| TBD
-}
orRd : Nonempty.Nonempty Color
orRd =
Nonempty.Nonempty (rgb255 255 247 236) [ rgb255 254 232 200, rgb255 253 212 158, rgb255 253 187 132, rgb255 252 141 89, rgb255 239 101 72, rgb255 215 48 31, rgb255 179 0 0, rgb255 127 0 0 ]


{-| TBD
-}
puBu : Nonempty.Nonempty Color
puBu =
Nonempty.Nonempty (rgb255 255 247 251) [ rgb255 236 231 242, rgb255 208 209 230, rgb255 166 189 219, rgb255 116 169 207, rgb255 54 144 192, rgb255 5 112 176, rgb255 4 90 141, rgb255 2 56 88 ]


{-| TBD
-}
puBuGn : Nonempty.Nonempty Color
puBuGn =
Nonempty.Nonempty (rgb255 255 247 251) [ rgb255 236 226 240, rgb255 208 209 230, rgb255 166 189 219, rgb255 103 169 207, rgb255 54 144 192, rgb255 2 129 138, rgb255 1 108 89, rgb255 1 70 54 ]


{-| TBD
-}
puRd : Nonempty.Nonempty Color
puRd =
Nonempty.Nonempty (rgb255 247 244 249) [ rgb255 231 225 239, rgb255 212 185 218, rgb255 201 148 199, rgb255 223 101 176, rgb255 231 41 138, rgb255 206 18 86, rgb255 152 0 67, rgb255 103 0 31 ]


{-| TBD
-}
rdPu : Nonempty.Nonempty Color
rdPu =
Nonempty.Nonempty (rgb255 255 247 243) [ rgb255 253 224 221, rgb255 252 197 192, rgb255 250 159 181, rgb255 247 104 161, rgb255 221 52 151, rgb255 174 1 126, rgb255 122 1 119, rgb255 73 0 106 ]


{-| TBD
-}
ylGn : Nonempty.Nonempty Color
ylGn =
Nonempty.Nonempty (rgb255 255 255 229) [ rgb255 247 252 185, rgb255 217 240 163, rgb255 173 221 142, rgb255 120 198 121, rgb255 65 171 93, rgb255 35 132 67, rgb255 0 104 55, rgb255 0 69 41 ]


{-| TBD
-}
ylGnBu : Nonempty.Nonempty Color
ylGnBu =
Nonempty.Nonempty (rgb255 255 255 217) [ rgb255 237 248 177, rgb255 199 233 180, rgb255 127 205 187, rgb255 65 182 196, rgb255 29 145 192, rgb255 34 94 168, rgb255 37 52 148, rgb255 8 29 88 ]


{-| TBD
-}
ylOrBr : Nonempty.Nonempty Color
ylOrBr =
Nonempty.Nonempty (rgb255 255 255 229) [ rgb255 255 247 188, rgb255 254 227 145, rgb255 254 196 79, rgb255 254 153 41, rgb255 236 112 20, rgb255 204 76 2, rgb255 153 52 4, rgb255 102 37 6 ]


{-| TBD
-}
ylOrRd : Nonempty.Nonempty Color
ylOrRd =
Nonempty.Nonempty (rgb255 255 255 204) [ rgb255 255 237 160, rgb255 254 217 118, rgb255 254 178 76, rgb255 253 141 60, rgb255 252 78 42, rgb255 227 26 28, rgb255 189 0 38, rgb255 128 0 38 ]



-- Sequential - Single Hue


{-| TBD
-}
blues : Nonempty.Nonempty Color
blues =
Nonempty.Nonempty (rgb255 247 251 255) [ rgb255 222 235 247, rgb255 198 219 239, rgb255 158 202 225, rgb255 107 174 214, rgb255 66 146 198, rgb255 33 113 181, rgb255 8 81 156, rgb255 8 48 107 ]


{-| TBD
-}
greens : Nonempty.Nonempty Color
greens =
Nonempty.Nonempty (rgb255 247 252 245) [ rgb255 229 245 224, rgb255 199 233 192, rgb255 161 217 155, rgb255 116 196 118, rgb255 65 171 93, rgb255 35 139 69, rgb255 0 109 44, rgb255 0 68 27 ]


{-| TBD
-}
greys : Nonempty.Nonempty Color
greys =
Nonempty.Nonempty (rgb255 255 255 255) [ rgb255 240 240 240, rgb255 217 217 217, rgb255 189 189 189, rgb255 150 150 150, rgb255 115 115 115, rgb255 82 82 82, rgb255 37 37 37, rgb255 0 0 0 ]


{-| TBD
-}
oranges : Nonempty.Nonempty Color
oranges =
Nonempty.Nonempty (rgb255 255 245 235) [ rgb255 254 230 206, rgb255 253 208 162, rgb255 253 174 107, rgb255 253 141 60, rgb255 241 105 19, rgb255 217 72 1, rgb255 166 54 3, rgb255 127 39 4 ]


{-| TBD
-}
purples : Nonempty.Nonempty Color
purples =
Nonempty.Nonempty (rgb255 252 251 253) [ rgb255 239 237 245, rgb255 218 218 235, rgb255 188 189 220, rgb255 158 154 200, rgb255 128 125 186, rgb255 106 81 163, rgb255 84 39 143, rgb255 63 0 125 ]


{-| TBD
-}
reds : Nonempty.Nonempty Color
reds =
Nonempty.Nonempty (rgb255 255 245 240) [ rgb255 254 224 210, rgb255 252 187 161, rgb255 252 146 114, rgb255 251 106 74, rgb255 239 59 44, rgb255 203 24 29, rgb255 165 15 21, rgb255 103 0 13 ]



-- Diverging
-- Change to 11 not 9 - First 3 done https://github.com/gka/chroma.js/blob/master/src/colors/colorbrewer.js


{-| TBD
-}
brBG : Nonempty.Nonempty Color
brBG =
Nonempty.Nonempty (rgb255 84 48 5) [ rgb255 140 81 10, rgb255 191 129 45, rgb255 223 194 125, rgb255 246 232 195, rgb255 245 245 245, rgb255 199 234 229, rgb255 128 205 193, rgb255 53 151 143, rgb255 1 102 94, rgb255 0 60 48 ]


{-| TBD
-}
piYG : Nonempty.Nonempty Color
piYG =
Nonempty.Nonempty (rgb255 142 1 82) [ rgb255 197 27 125, rgb255 222 119 174, rgb255 241 182 218, rgb255 253 224 239, rgb255 247 247 247, rgb255 230 245 208, rgb255 184 225 134, rgb255 127 188 65, rgb255 77 146 33, rgb255 39 100 25 ]


{-| TBD
-}
pRGn : Nonempty.Nonempty Color
pRGn =
Nonempty.Nonempty (rgb255 64 0 75) [ rgb255 118 42 131, rgb255 153 112 171, rgb255 194 165 207, rgb255 231 212 232, rgb255 247 247 247, rgb255 217 240 211, rgb255 166 219 160, rgb255 90 174 97, rgb255 27 120 55, rgb255 0 68 27 ]


{-| TBD
-}
puOr : Nonempty.Nonempty Color
puOr =
Nonempty.Nonempty (rgb255 127 59 8) [ rgb255 179 88 6, rgb255 224 130 20, rgb255 253 184 99, rgb255 254 224 182, rgb255 247 247 247, rgb255 216 218 235, rgb255 178 171 210, rgb255 128 115 172, rgb255 84 39 136, rgb255 45 0 75 ]


{-| TBD
-}
rdYlGn : Nonempty.Nonempty Color
rdYlGn =
Nonempty.Nonempty (rgb255 165 0 38) [ rgb255 215 48 39, rgb255 244 109 67, rgb255 253 174 97, rgb255 254 224 139, rgb255 255 255 191, rgb255 217 239 139, rgb255 166 217 106, rgb255 102 189 99, rgb255 26 152 80, rgb255 0 104 55 ]


{-| TBD
-}
rdBu : Nonempty.Nonempty Color
rdBu =
Nonempty.Nonempty (rgb255 103 0 31) [ rgb255 178 24 43, rgb255 214 96 77, rgb255 244 165 130, rgb255 253 219 199, rgb255 247 247 247, rgb255 209 229 240, rgb255 146 197 222, rgb255 67 147 195, rgb255 33 102 172, rgb255 5 48 97 ]


{-| TBD
-}
rdGy : Nonempty.Nonempty Color
rdGy =
Nonempty.Nonempty (rgb255 103 0 31) [ rgb255 178 24 43, rgb255 214 96 77, rgb255 244 165 130, rgb255 253 219 199, rgb255 255 255 255, rgb255 224 224 224, rgb255 186 186 186, rgb255 135 135 135, rgb255 77 77 77, rgb255 26 26 26 ]


{-| TBD
-}
rdYlBu : Nonempty.Nonempty Color
rdYlBu =
Nonempty.Nonempty (rgb255 165 0 38) [ rgb255 215 48 39, rgb255 244 109 67, rgb255 253 174 97, rgb255 254 224 144, rgb255 255 255 191, rgb255 224 243 248, rgb255 171 217 233, rgb255 116 173 209, rgb255 69 117 180, rgb255 49 54 149 ]


{-| TBD
-}
spectral : Nonempty.Nonempty Color
spectral =
Nonempty.Nonempty (rgb255 158 1 66) [ rgb255 213 62 79, rgb255 244 109 67, rgb255 253 174 97, rgb255 254 224 139, rgb255 255 255 191, rgb255 230 245 152, rgb255 171 221 164, rgb255 102 194 165, rgb255 50 136 189, rgb255 94 79 162 ]



-- Qualitative


{-| TBD
-}
accent : Nonempty.Nonempty Color
accent =
Nonempty.Nonempty (rgb255 127 201 127) [ rgb255 190 174 212, rgb255 253 192 134, rgb255 255 255 153, rgb255 56 108 176, rgb255 240 2 127, rgb255 191 91 23, rgb255 102 102 102 ]


{-| TBD
-}
dark2 : Nonempty.Nonempty Color
dark2 =
Nonempty.Nonempty (rgb255 27 158 119) [ rgb255 217 95 2, rgb255 117 112 179, rgb255 231 41 138, rgb255 102 166 30, rgb255 230 171 2, rgb255 166 118 29, rgb255 102 102 102 ]


{-| TBD
-}
paired : Nonempty.Nonempty Color
paired =
Nonempty.Nonempty (rgb255 166 206 227) [ rgb255 31 120 180, rgb255 178 223 138, rgb255 51 160 44, rgb255 251 154 153, rgb255 227 26 28, rgb255 253 191 111, rgb255 255 127 0, rgb255 202 178 214, rgb255 106 61 154, rgb255 255 255 153, rgb255 177 89 40 ]


{-| TBD
-}
pastel1 : Nonempty.Nonempty Color
pastel1 =
Nonempty.Nonempty (rgb255 251 180 174) [ rgb255 179 205 227, rgb255 204 235 197, rgb255 222 203 228, rgb255 254 217 166, rgb255 255 255 204, rgb255 229 216 189, rgb255 253 218 236, rgb255 242 242 242 ]


{-| TBD
-}
pastel2 : Nonempty.Nonempty Color
pastel2 =
Nonempty.Nonempty (rgb255 179 226 205) [ rgb255 253 205 172, rgb255 203 213 232, rgb255 244 202 228, rgb255 230 245 201, rgb255 255 242 174, rgb255 241 226 204, rgb255 204 204 204 ]


{-| TBD
-}
set1 : Nonempty.Nonempty Color
set1 =
Nonempty.Nonempty (rgb255 228 26 28) [ rgb255 55 126 184, rgb255 77 175 74, rgb255 152 78 163, rgb255 255 127 0, rgb255 255 255 51, rgb255 166 86 40, rgb255 247 129 191, rgb255 153 153 153 ]


{-| TBD
-}
set2 : Nonempty.Nonempty Color
set2 =
Nonempty.Nonempty (rgb255 102 194 165) [ rgb255 252 141 98, rgb255 141 160 203, rgb255 231 138 195, rgb255 166 216 84, rgb255 255 217 47, rgb255 229 196 148, rgb255 179 179 179 ]


{-| TBD
-}
set3 : Nonempty.Nonempty Color
set3 =
Nonempty.Nonempty (rgb255 141 211 199) [ rgb255 255 255 179, rgb255 190 186 218, rgb255 251 128 114, rgb255 128 177 211, rgb255 253 180 98, rgb255 179 222 105, rgb255 252 205 229, rgb255 217 217 217, rgb255 188 128 189, rgb255 204 235 197, rgb255 255 237 111 ]

module Chroma.Colors.Cividis exposing (getColor)

{-| [Cividis](https://github.com/marcosci/cividis)

Enables nearly-identical visual-data interpretation to color vision deficiency (CVD) people. It is perceptually
uniform in hue and brightness, and increases in brightness linearly.


# Color Scale

@docs getColor

-}

import Color exposing (Color, rgb255)


{-| TBD
-}
getColor : Float -> Color
getColor t =
let
boundedT =
clamp 0 1 t

r =
max 0 (min 255 (round (-4.54 - boundedT * (35.34 - boundedT * (2381.73 - boundedT * (6402.7 - boundedT * (7024.72 - boundedT * 2710.57)))))))

g =
max 0 (min 255 (round (32.49 + boundedT * (170.73 + boundedT * (52.82 - boundedT * (131.46 - boundedT * (176.58 - boundedT * 67.37)))))))

b =
max 0 (min 255 (round (81.24 + boundedT * (442.36 - boundedT * (2482.43 - boundedT * (6167.24 - boundedT * (6614.94 - boundedT * 2475.67)))))))
in
rgb255 r g b