package colorful

Import Path
	github.com/lucasb-eyer/go-colorful (on go.dev)

Dependency Relation
	imports 7 packages, and imported by 3 packages

Involved Source Files

	    colorgens.go
	  d colors.go
		The colorful package provides all kinds of functions for working with colors.

	    happy_palettegen.go
	    hexcolor.go
	    hsluv.go
	    soft_palettegen.go
	    warm_palettegen.go
Package-Level Type Names (total 3)

	/* sort by: alphabet | popularity */
	 type Color (struct)
		A color is stored internally using sRGB (standard RGB) values in the range 0-1

		Fields (total 3)
			B float64
			G float64
			R float64
		Methods (total 39)
			( Color) AlmostEqualRgb(c2 Color) bool
				Check for equality between colors within the tolerance Delta (1/255).

			( Color) BlendHcl(col2 Color, t float64) Color
				BlendHcl blends two colors in the CIE-L*C*h° color-space, which should result in a smoother blend.
				t == 0 results in c1, t == 1 results in c2

			( Color) BlendHsv(c2 Color, t float64) Color
				You don't really want to use this, do you? Go for BlendLab, BlendLuv or BlendHcl.

			( Color) BlendLab(c2 Color, t float64) Color
				BlendLab blends two colors in the L*a*b* color-space, which should result in a smoother blend.
				t == 0 results in c1, t == 1 results in c2

			( Color) BlendLuv(c2 Color, t float64) Color
				BlendLuv blends two colors in the CIE-L*u*v* color-space, which should result in a smoother blend.
				t == 0 results in c1, t == 1 results in c2

			( Color) BlendLuvLCh(col2 Color, t float64) Color
				BlendLuvLCh blends two colors in the cylindrical CIELUV color space.
				t == 0 results in c1, t == 1 results in c2

			( Color) BlendRgb(c2 Color, t float64) Color
				You don't really want to use this, do you? Go for BlendLab, BlendLuv or BlendHcl.

			( Color) Clamped() Color
				Returns Clamps the color into valid range, clamping each value to [0..1]
				If the color is valid already, this is a no-op.

			( Color) DistanceCIE76(c2 Color) float64
				DistanceCIE76 is the same as DistanceLab.

			( Color) DistanceCIE94(cr Color) float64
				Uses the CIE94 formula to calculate color distance. More accurate than
				DistanceLab, but also more work.

			( Color) DistanceCIEDE2000(cr Color) float64
				DistanceCIEDE2000 uses the Delta E 2000 formula to calculate color
				distance. It is more expensive but more accurate than both DistanceLab
				and DistanceCIE94.

			( Color) DistanceCIEDE2000klch(cr Color, kl, kc, kh float64) float64
				DistanceCIEDE2000klch uses the Delta E 2000 formula with custom values
				for the weighting factors kL, kC, and kH.

			( Color) DistanceHPLuv(c2 Color) float64
				DistanceHPLuv calculates Euclidean distance in the HPLuv colorspace. No idea
				how useful this is.
				
				The Hue value is divided by 100 before the calculation, so that H, S, and L
				have the same relative ranges.

			( Color) DistanceHSLuv(c2 Color) float64
				DistanceHSLuv calculates Euclidan distance in the HSLuv colorspace. No idea
				how useful this is.
				
				The Hue value is divided by 100 before the calculation, so that H, S, and L
				have the same relative ranges.

			( Color) DistanceLab(c2 Color) float64
				DistanceLab is a good measure of visual similarity between two colors!
				A result of 0 would mean identical colors, while a result of 1 or higher
				means the colors differ a lot.

			( Color) DistanceLinearRGB(c2 Color) float64
				DistanceLinearRGB computes the distance between two colors in linear RGB
				space. This is not useful for measuring how humans perceive color, but
				might be useful for other things, like dithering.

			( Color) DistanceLuv(c2 Color) float64
				DistanceLuv is a good measure of visual similarity between two colors!
				A result of 0 would mean identical colors, while a result of 1 or higher
				means the colors differ a lot.

			( Color) DistanceRgb(c2 Color) float64
				DistanceRgb computes the distance between two colors in RGB space.
				This is not a good measure! Rather do it in Lab space.

			( Color) FastLinearRgb() (r, g, b float64)
				FastLinearRgb is much faster than and almost as accurate as LinearRgb.
				BUT it is important to NOTE that they only produce good results for valid colors r,g,b in [0,1].

			( Color) HPLuv() (h, s, l float64)
				HPLuv returns the Hue, Saturation and Luminance of the color in the HSLuv
				color space. Hue in [0..360], a Saturation [0..1], and a Luminance
				(lightness) in [0..1].
				
				Note that HPLuv can only represent pastel colors, and so the Saturation
				value could be much larger than 1 for colors it can't represent.

			( Color) HSLuv() (h, s, l float64)
				HSLuv returns the Hue, Saturation and Luminance of the color in the HSLuv
				color space. Hue in [0..360], a Saturation [0..1], and a Luminance
				(lightness) in [0..1].

			( Color) Hcl() (h, c, l float64)
				Converts the given color to HCL space using D65 as reference white.
				H values are in [0..360], C and L values are in [0..1] although C can overshoot 1.0

			( Color) HclWhiteRef(wref [3]float64) (h, c, l float64)
				Converts the given color to HCL space, taking into account
				a given reference white. (i.e. the monitor's white)
				H values are in [0..360], C and L values are in [0..1]

			( Color) Hex() string
				Hex returns the hex "html" representation of the color, as in #ff0080.

			( Color) Hsl() (h, s, l float64)
				Hsl returns the Hue [0..360], Saturation [0..1], and Luminance (lightness) [0..1] of the color.

			( Color) Hsv() (h, s, v float64)
				Hsv returns the Hue [0..360], Saturation and Value [0..1] of the color.

			( Color) IsValid() bool
				Checks whether the color exists in RGB space, i.e. all values are in [0..1]

			( Color) Lab() (l, a, b float64)
				Converts the given color to CIE L*a*b* space using D65 as reference white.

			( Color) LabWhiteRef(wref [3]float64) (l, a, b float64)
				Converts the given color to CIE L*a*b* space, taking into account
				a given reference white. (i.e. the monitor's white)

			( Color) LinearRgb() (r, g, b float64)
				LinearRgb converts the color into the linear RGB space (see http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/).

			( Color) Luv() (l, u, v float64)
				Converts the given color to CIE L*u*v* space using D65 as reference white.
				L* is in [0..1] and both u* and v* are in about [-1..1]

			( Color) LuvLCh() (l, c, h float64)
				Converts the given color to LuvLCh space using D65 as reference white.
				h values are in [0..360], C and L values are in [0..1] although C can overshoot 1.0

			( Color) LuvLChWhiteRef(wref [3]float64) (l, c, h float64)
				Converts the given color to LuvLCh space, taking into account
				a given reference white. (i.e. the monitor's white)
				h values are in [0..360], c and l values are in [0..1]

			( Color) LuvWhiteRef(wref [3]float64) (l, u, v float64)
				Converts the given color to CIE L*u*v* space, taking into account
				a given reference white. (i.e. the monitor's white)
				L* is in [0..1] and both u* and v* are in about [-1..1]

			( Color) RGB255() (r, g, b uint8)
				Might come in handy sometimes to reduce boilerplate code.

			( Color) RGBA() (r, g, b, a uint32)
				Implement the Go color.Color interface.

			( Color) Xyy() (x, y, Y float64)
				Converts the given color to CIE xyY space using D65 as reference white.
				(Note that the reference white is only used for black input.)
				x, y and Y are in [0..1]

			( Color) XyyWhiteRef(wref [3]float64) (x, y, Y float64)
				Converts the given color to CIE xyY space, taking into account
				a given reference white. (i.e. the monitor's white)
				(Note that the reference white is only used for black input.)
				x, y and Y are in [0..1]

			( Color) Xyz() (x, y, z float64)
		Implements (at least 2)
			 Color : database/sql/driver.Validator
			 Color : image/color.Color
		As Outputs Of (at least 35)
			func FastHappyColor() Color
			func FastHappyPalette(colorsCount int) (colors []Color)
			func FastLinearRgb(r, g, b float64) Color
			func FastWarmColor() Color
			func FastWarmPalette(colorsCount int) (colors []Color)
			func HappyColor() (c Color)
			func HappyPalette(colorsCount int) ([]Color, error)
			func Hcl(h, c, l float64) Color
			func HclWhiteRef(h, c, l float64, wref [3]float64) Color
			func Hex(scol string) (Color, error)
			func HPLuv(h, s, l float64) Color
			func Hsl(h, s, l float64) Color
			func HSLuv(h, s, l float64) Color
			func Hsv(H, S, V float64) Color
			func Lab(l, a, b float64) Color
			func LabWhiteRef(l, a, b float64, wref [3]float64) Color
			func LinearRgb(r, g, b float64) Color
			func Luv(l, u, v float64) Color
			func LuvLCh(l, c, h float64) Color
			func LuvLChWhiteRef(l, c, h float64, wref [3]float64) Color
			func LuvWhiteRef(l, u, v float64, wref [3]float64) Color
			func MakeColor(col color.Color) (Color, bool)
			func SoftPalette(colorsCount int) ([]Color, error)
			func SoftPaletteEx(colorsCount int, settings SoftPaletteSettings) ([]Color, error)
			func WarmColor() (c Color)
			func WarmPalette(colorsCount int) ([]Color, error)
			func Xyy(x, y, Y float64) Color
			func Xyz(x, y, z float64) Color
			func Color.BlendHcl(col2 Color, t float64) Color
			func Color.BlendHsv(c2 Color, t float64) Color
			func Color.BlendLab(c2 Color, t float64) Color
			func Color.BlendLuv(c2 Color, t float64) Color
			func Color.BlendLuvLCh(col2 Color, t float64) Color
			func Color.BlendRgb(c2 Color, t float64) Color
			func Color.Clamped() Color
		As Inputs Of (at least 17)
			func Color.AlmostEqualRgb(c2 Color) bool
			func Color.BlendHcl(col2 Color, t float64) Color
			func Color.BlendHsv(c2 Color, t float64) Color
			func Color.BlendLab(c2 Color, t float64) Color
			func Color.BlendLuv(c2 Color, t float64) Color
			func Color.BlendLuvLCh(col2 Color, t float64) Color
			func Color.BlendRgb(c2 Color, t float64) Color
			func Color.DistanceCIE76(c2 Color) float64
			func Color.DistanceCIE94(cr Color) float64
			func Color.DistanceCIEDE2000(cr Color) float64
			func Color.DistanceCIEDE2000klch(cr Color, kl, kc, kh float64) float64
			func Color.DistanceHPLuv(c2 Color) float64
			func Color.DistanceHSLuv(c2 Color) float64
			func Color.DistanceLab(c2 Color) float64
			func Color.DistanceLinearRGB(c2 Color) float64
			func Color.DistanceLuv(c2 Color) float64
			func Color.DistanceRgb(c2 Color) float64

	 type HexColor Color (struct)
		A HexColor is a Color stored as a hex string "#rrggbb". It implements the
		database/sql.Scanner, database/sql/driver.Value,
		encoding/json.Unmarshaler and encoding/json.Marshaler interfaces.

		Fields (total 3)
			B float64
			G float64
			R float64
		Methods (total 5)
			(*HexColor) Decode(hexCode string) error
				Decode - deserialize function for https://github.com/kelseyhightower/envconfig

			( HexColor) MarshalJSON() ([]byte, error)
			(*HexColor) Scan(value interface{}) error
			(*HexColor) UnmarshalJSON(data []byte) error
			(*HexColor) Value() (driver.Value, error)
		Implements (at least 6)
			 HexColor : github.com/goccy/go-json.Marshaler
			*HexColor : github.com/goccy/go-json.Unmarshaler
			*HexColor : database/sql.Scanner
			*HexColor : database/sql/driver.Valuer
			 HexColor : encoding/json.Marshaler
			*HexColor : encoding/json.Unmarshaler

	 type SoftPaletteSettings (struct)

		Fields (total 3)
			CheckColor func(l, a, b float64) bool
				A function which can be used to restrict the allowed color-space.

			Iterations int
				The higher, the better quality but the slower. Usually two figures.

			ManySamples bool
				Use up to 160000 or 8000 samples of the L*a*b* space (and thus calls to CheckColor).
				Set this to true only if your CheckColor shapes the Lab space weirdly.

		As Inputs Of (at least one exported)
			func SoftPaletteEx(colorsCount int, settings SoftPaletteSettings) ([]Color, error)


Package-Level Functions (total 49)

	 func FastHappyColor() Color
		Creates a random bright, "pimpy" color through a restricted HSV space.

	 func FastHappyPalette(colorsCount int) (colors []Color)
		Uses the HSV color space to generate colors with similar S,V but distributed
		evenly along their Hue. This is fast but not always pretty.
		If you've got time to spare, use Lab (the non-fast below).

	 func FastLinearRgb(r, g, b float64) Color
		FastLinearRgb is much faster than and almost as accurate as LinearRgb.
		BUT it is important to NOTE that they only produce good results for valid inputs r,g,b in [0,1].

	 func FastWarmColor() Color
		Creates a random dark, "warm" color through a restricted HSV space.

	 func FastWarmPalette(colorsCount int) (colors []Color)
		Uses the HSV color space to generate colors with similar S,V but distributed
		evenly along their Hue. This is fast but not always pretty.
		If you've got time to spare, use Lab (the non-fast below).

	 func HappyColor() (c Color)
		Creates a random bright, "pimpy" color through restricted HCL space.
		This is slower than FastHappyColor but will likely give you colors which
		have the same "brightness" if you run it many times.

	 func HappyPalette(colorsCount int) ([]Color, error)
	 func Hcl(h, c, l float64) Color
		Generates a color by using data given in HCL space using D65 as reference white.
		H values are in [0..360], C and L values are in [0..1]
		WARNING: many combinations of `h`, `c`, and `l` values do not have corresponding
		valid RGB values, check the FAQ in the README if you're unsure.

	 func HclToLab(h, c, l float64) (L, a, b float64)
	 func HclWhiteRef(h, c, l float64, wref [3]float64) Color
		Generates a color by using data given in HCL space, taking
		into account a given reference white. (i.e. the monitor's white)
		H values are in [0..360], C and L values are in [0..1]

	 func Hex(scol string) (Color, error)
		Hex parses a "html" hex color-string, either in the 3 "#f0c" or 6 "#ff1034" digits form.

	 func HPLuv(h, s, l float64) Color
		HPLuv creates a new Color from values in the HPLuv color space.
		Hue in [0..360], a Saturation [0..1], and a Luminance (lightness) in [0..1].
		
		The returned color values are clamped (using .Clamped), so this will never output
		an invalid color.

	 func HPLuvToLuvLCh(h, s, l float64) (float64, float64, float64)
	 func Hsl(h, s, l float64) Color
		Hsl creates a new Color given a Hue in [0..360], a Saturation [0..1], and a Luminance (lightness) in [0..1]

	 func HSLuv(h, s, l float64) Color
		HSLuv creates a new Color from values in the HSLuv color space.
		Hue in [0..360], a Saturation [0..1], and a Luminance (lightness) in [0..1].
		
		The returned color values are clamped (using .Clamped), so this will never output
		an invalid color.

	 func HSLuvToLuvLCh(h, s, l float64) (float64, float64, float64)
	 func Hsv(H, S, V float64) Color
		Hsv creates a new Color given a Hue in [0..360], a Saturation and a Value in [0..1]

	 func Lab(l, a, b float64) Color
		Generates a color by using data given in CIE L*a*b* space using D65 as reference white.
		WARNING: many combinations of `l`, `a`, and `b` values do not have corresponding
		valid RGB values, check the FAQ in the README if you're unsure.

	 func LabToHcl(L, a, b float64) (h, c, l float64)
	 func LabToXyz(l, a, b float64) (x, y, z float64)
	 func LabToXyzWhiteRef(l, a, b float64, wref [3]float64) (x, y, z float64)
	 func LabWhiteRef(l, a, b float64, wref [3]float64) Color
		Generates a color by using data given in CIE L*a*b* space, taking
		into account a given reference white. (i.e. the monitor's white)

	 func LinearRgb(r, g, b float64) Color
		LinearRgb creates an sRGB color out of the given linear RGB color (see http://www.sjbrown.co.uk/2004/05/14/gamma-correct-rendering/).

	 func LinearRgbToXyz(r, g, b float64) (x, y, z float64)
	 func Luv(l, u, v float64) Color
		Generates a color by using data given in CIE L*u*v* space using D65 as reference white.
		L* is in [0..1] and both u* and v* are in about [-1..1]
		WARNING: many combinations of `l`, `u`, and `v` values do not have corresponding
		valid RGB values, check the FAQ in the README if you're unsure.

	 func LuvLCh(l, c, h float64) Color
		Generates a color by using data given in LuvLCh space using D65 as reference white.
		h values are in [0..360], C and L values are in [0..1]
		WARNING: many combinations of `l`, `c`, and `h` values do not have corresponding
		valid RGB values, check the FAQ in the README if you're unsure.

	 func LuvLChToHPLuv(l, c, h float64) (float64, float64, float64)
	 func LuvLChToHSLuv(l, c, h float64) (float64, float64, float64)
	 func LuvLChToLuv(l, c, h float64) (L, u, v float64)
	 func LuvLChWhiteRef(l, c, h float64, wref [3]float64) Color
		Generates a color by using data given in LuvLCh space, taking
		into account a given reference white. (i.e. the monitor's white)
		h values are in [0..360], C and L values are in [0..1]

	 func LuvToLuvLCh(L, u, v float64) (l, c, h float64)
	 func LuvToXyz(l, u, v float64) (x, y, z float64)
	 func LuvToXyzWhiteRef(l, u, v float64, wref [3]float64) (x, y, z float64)
	 func LuvWhiteRef(l, u, v float64, wref [3]float64) Color
		Generates a color by using data given in CIE L*u*v* space, taking
		into account a given reference white. (i.e. the monitor's white)
		L* is in [0..1] and both u* and v* are in about [-1..1]

	 func MakeColor(col color.Color) (Color, bool)
		Constructs a colorful.Color from something implementing color.Color

	 func SoftPalette(colorsCount int) ([]Color, error)
		A wrapper which uses common parameters.

	 func SoftPaletteEx(colorsCount int, settings SoftPaletteSettings) ([]Color, error)
		Yeah, windows-stype Foo, FooEx, screw you golang...
		Uses K-means to cluster the color-space and return the means of the clusters
		as a new palette of distinctive colors. Falls back to K-medoid if the mean
		happens to fall outside of the color-space, which can only happen if you
		specify a CheckColor function.

	 func WarmColor() (c Color)
		Creates a random dark, "warm" color through restricted HCL space.
		This is slower than FastWarmColor but will likely give you colors which have
		the same "warmness" if you run it many times.

	 func WarmPalette(colorsCount int) ([]Color, error)
	 func Xyy(x, y, Y float64) Color
		Generates a color by using data given in CIE xyY space.
		x, y and Y are in [0..1]

	 func XyyToXyz(x, y, Y float64) (X, Yout, Z float64)
	 func Xyz(x, y, z float64) Color
	 func XyzToLab(x, y, z float64) (l, a, b float64)
	 func XyzToLabWhiteRef(x, y, z float64, wref [3]float64) (l, a, b float64)
	 func XyzToLinearRgb(x, y, z float64) (r, g, b float64)
		XyzToLinearRgb converts from CIE XYZ-space to Linear RGB space.

	 func XyzToLuv(x, y, z float64) (l, a, b float64)
	 func XyzToLuvWhiteRef(x, y, z float64, wref [3]float64) (l, u, v float64)
	 func XyzToXyy(X, Y, Z float64) (x, y, Yout float64)
		Well, the name is bad, since it's xyY but Golang needs me to start with a
		capital letter to make the method public.

	 func XyzToXyyWhiteRef(X, Y, Z float64, wref [3]float64) (x, y, Yout float64)
Package-Level Variables (total 2)

	  var D50 [3]float64
		And another one.

	  var D65 [3]float64
		This is the default reference white point.


Package-Level Constants (total 2)

	const Delta = 0.00392157
		This is the tolerance used when comparing colors using AlmostEqualRgb.

	const LAB_DELTA = 1e-06

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.