noire.go

package noire

import (
	"encoding/hex"
	"fmt"
	"math"
	"strings"
)

// Color represents a manipulable color.
type Color struct {
	Red   float64
	Green float64
	Blue  float64
	Alpha float64
}

// newColor returns a new color.
func newColor(r float64, g float64, b float64, a float64) Color {
	if r > 255 {
		r = 255
	} else if r < 0 {
		r = 0
	}
	if g > 255 {
		g = 255
	} else if g < 0 {
		g = 0
	}
	if b > 255 {
		b = 255
	} else if b < 0 {
		b = 0
	}
	if a > 1 {
		a = 1
	} else if a < 0 {
		a = 0
	}
	return Color{
		Red:   r,
		Green: g,
		Blue:  b,
		Alpha: a,
	}
}

// CMYKToRGB converts the color from CMYK to RGB with a lossy algorithm.
//
// reference: https://www.ginifab.com.tw/tools/colors/js/colorconverter.js
func CMYKToRGB(c float64, m float64, y float64, k float64) (r float64, g float64, b float64) {
	c = c / 100
	m = m / 100
	y = y / 100
	k = k / 100

	r = 1 - math.Min(1, c*(1-k)+k)
	g = 1 - math.Min(1, m*(1-k)+k)
	b = 1 - math.Min(1, y*(1-k)+k)

	r = math.Round(r * 255)
	g = math.Round(g * 255)
	b = math.Round(b * 255)

	return
}

// RGBToCMYK converts the color from RGB to CMYK with a lossy algorithm.
//
// reference: https://www.ginifab.com.tw/tools/colors/js/colorconverter.js
func RGBToCMYK(r float64, g float64, b float64) (c float64, m float64, y float64, k float64) {
	r = r / 255
	g = g / 255
	b = b / 255

	k = math.Min(1-r, 1-g)
	k = math.Min(k, 1-b)
	if (1 - k) == 0 {
		c = 0
		m = 0
		y = 0
	} else {
		c = (1 - r - k) / (1 - k)
		m = (1 - g - k) / (1 - k)
		y = (1 - b - k) / (1 - k)
	}
	c = math.Round(c * 100)
	m = math.Round(m * 100)
	y = math.Round(y * 100)
	k = math.Round(k * 100)
	return
}

// HueToRGB converts the color from Hue to RGB.
//
// reference: https://www.ginifab.com.tw/tools/colors/js/colorconverter.js
func HueToRGB(p float64, q float64, t float64) float64 {

	if t < 0 {
		t++
	}
	if t > 1 {
		t--
	}
	if t < float64(1)/float64(6) {
		return p + (q-p)*6*t
	}
	if t < float64(1)/float64(2) {
		return q
	}
	if t < float64(2)/float64(3) {
		return p + (q-p)*(float64(2)/float64(3)-t)*6
	}
	return p
}

// RGBToHSL converts the color from RGB to HSL with a lossy algorithm.
//
// reference: https://www.ginifab.com.tw/tools/colors/js/colorconverter.js
func RGBToHSL(r float64, g float64, b float64) (h float64, s float64, l float64) {
	r = r / 255
	g = g / 255
	b = b / 255
	max := math.Max(r, g)
	max = math.Max(max, b)
	min := math.Min(r, g)
	min = math.Min(min, b)
	l = (max + min) / 2
	if max == min {
		h = 0
		s = 0
	} else {
		d := max - min
		if l > 0.5 {
			s = d / (2 - max - min)
		} else {
			s = d / (max + min)
		}
		switch max {
		case r:
			if g < b {
				h = (g-b)/d + 6
			} else {
				h = (g-b)/d + 0
			}
			break
		case g:
			h = (b-r)/d + 2
			break
		case b:
			h = (r-g)/d + 4
			break
		}
	}
	h = math.Round(h * 60)
	s = math.Round(s*1000) / 10
	l = math.Round(l*1000) / 10
	return
}

// HSLToRGB converts the color from HSL to RGB with a lossy algorithm.
//
// reference: https://www.ginifab.com.tw/tools/colors/js/colorconverter.js
func HSLToRGB(h float64, s float64, l float64) (r float64, g float64, b float64) {
	h = h / 360
	s = s / 100
	l = l / 100

	if s == 0 {
		r = l
		g = l
		b = l
	} else {
		var q float64
		if l < 0.5 {
			q = l * (1 + s)
		} else {
			q = l + s - l*s
		}
		p := 2*l - q
		r = HueToRGB(p, q, h+float64(float64(1)/float64(3)))
		g = HueToRGB(p, q, h)
		b = HueToRGB(p, q, h-float64(float64(1)/float64(3)))
	}
	r = math.Round(r * 255)
	g = math.Round(g * 255)
	b = math.Round(b * 255)
	return
}

// HSVToRGB converts the color from HSV to RGB with a lossy algorithm.
//
// reference: https://www.rapidtables.com/convert/color/hsv-to-rgb.html
func HSVToRGB(h float64, s float64, v float64) (r float64, g float64, b float64) {
	s = s / 100
	v = v / 100
	c := v * s
	hh := h / 60
	x := c * (1 - math.Abs(math.Mod(hh, 2)-1))
	if hh >= 0 && hh < 1 {
		r = c
		g = x
	} else if hh >= 1 && hh < 2 {
		r = x
		g = c
	} else if hh >= 2 && hh < 3 {
		g = c
		b = x
	} else if hh >= 3 && hh < 4 {
		g = x
		b = c
	} else if hh >= 4 && hh < 5 {
		r = x
		b = c
	} else {
		r = c
		b = x
	}
	m := v - c
	r += m
	g += m
	b += m
	r = math.Round(r * 255)
	g = math.Round(g * 255)
	b = math.Round(b * 255)
	return
}

// RGBToHSV converts the color from RGB to HSV with a lossy algorithm.
//
// reference: https://www.ginifab.com.tw/tools/colors/js/colorconverter.js
func RGBToHSV(r float64, g float64, b float64) (h float64, s float64, v float64) {
	r = r / 255
	g = g / 255
	b = b / 255

	minValue := math.Min(math.Min(r, g), b)
	maxValue := math.Max(math.Max(r, g), b)

	delta := maxValue - minValue
	v = maxValue

	if delta == 0 {
		h = 0
		s = 0
	} else {
		s = delta / maxValue
		deltaR := (((maxValue - r) / 6) + (delta / 2)) / delta
		deltaG := (((maxValue - g) / 6) + (delta / 2)) / delta
		deltaB := (((maxValue - b) / 6) + (delta / 2)) / delta
		switch maxValue {
		case r:
			h = deltaB - deltaG
			break
		case g:
			h = (float64(1) / float64(3)) + deltaR - deltaB
			break
		case b:
			h = (float64(2) / float64(3)) + deltaG - deltaR
			break
		}
		if h < 0 {
			h++
		}
		if h > 1 {
			h--
		}
	}

	h = math.Round(h * 360)
	s = math.Round(s*1000) / 10
	v = math.Round(v*1000) / 10
	return
}

// RGBToHex converts the color from RGB to a uppercased Hex string (without the `#` prefix).
func RGBToHex(r float64, g float64, b float64) string {
	h := []byte{uint8(math.Round(r)), uint8(math.Round(g)), uint8(math.Round(b))}
	return strings.ToUpper(hex.EncodeToString(h))
}

// HexToRGB converts the Hex string (can be `#` prefixed or either a 3 characters shorthand) to RGB.
func HexToRGB(h string) (r float64, g float64, b float64) {
	if string(h[0]) == "#" {
		h = h[1:]
	}
	if len(h) == 3 {
		h = string(h[0]) + string(h[0]) + string(h[1]) + string(h[1]) + string(h[2]) + string(h[2])
	}
	byteArray, _ := hex.DecodeString(h)
	r = float64(byteArray[0])
	g = float64(byteArray[1])
	b = float64(byteArray[2])
	return
}

// HTMLToRGB converts the color from HTML color name or a Hex string (can be `#` prefixed or either a 3 characters shorthand) to RGB.
func HTMLToRGB(h string) (r float64, g float64, b float64) {
	if string(h[0]) == "#" {
		h = h[1:]
		r, g, b = HexToRGB(h)
	} else {
		v, ok := colorNames[strings.ToUpper(h)]
		if !ok {
			r = 0
			g = 0
			b = 0
			return
		}
		r, g, b = HexToRGB(v)
	}
	return
}

// RGBToHTML converts the color from RGB to a `#` prefixed Hex string if it doesn't have a HTML color name.
func RGBToHTML(r float64, g float64, b float64) (h string) {
	h = RGBToHex(r, g, b)
	v, ok := hexNames[h]
	if !ok {
		h = "#" + h
		return
	}
	h = v
	return
}

// NewHTML initializes a color based on the HTML color name.
func NewHTML(color string) Color {
	r, g, b := HTMLToRGB(color)
	return newColor(r, g, b, 1)
}

// NewHTMLA initializes a color based on the HTML color name with an alpha channel.
func NewHTMLA(color string, a float64) Color {
	r, g, b := HTMLToRGB(color)
	return newColor(r, g, b, a)
}

// NewHex initializes a color based on a Hex string.
func NewHex(color string) Color {
	r, g, b := HexToRGB(color)
	return newColor(r, g, b, 1)
}

// NewHexA initializes a color based on a Hex string with an alpha channel.
func NewHexA(color string, a float64) Color {
	r, g, b := HexToRGB(color)
	return newColor(r, g, b, a)
}

// NewHSL initializes a color based on HSL.
func NewHSL(h float64, s float64, l float64) Color {
	r, g, b := HSLToRGB(h, s, l)
	return newColor(r, g, b, 1)
}

// NewHSLA initializes a color based on HSL with an alpha channel.
func NewHSLA(h float64, s float64, l float64, a float64) Color {
	r, g, b := HSLToRGB(h, s, l)
	return newColor(r, g, b, a)
}

// NewHSV initializes a color based on HSV.
func NewHSV(h float64, s float64, v float64) Color {
	r, g, b := HSVToRGB(h, s, v)
	return newColor(r, g, b, 1)
}

// NewHSVA initializes a color based on HSV with an alpha channel.
func NewHSVA(h float64, s float64, v float64, a float64) Color {
	r, g, b := HSVToRGB(h, s, v)
	return newColor(r, g, b, a)
}

// NewRGB initializes a color based on RGB.
func NewRGB(r float64, g float64, b float64) Color {
	return newColor(r, g, b, 1)
}

// NewRGBA initializes a color based on RGB with an alpha channel.
func NewRGBA(r float64, g float64, b float64, a float64) Color {
	return newColor(r, g, b, a)
}

// NewCMYK initializes a color based on CMYK.
func NewCMYK(c float64, m float64, y float64, k float64) Color {
	r, g, b := CMYKToRGB(c, m, y, k)
	return newColor(r, g, b, 1)
}

// NewCMYKA initializes a color based on CMYK with an alpha channel.
func NewCMYKA(c float64, m float64, y float64, k float64, a float64) Color {
	r, g, b := CMYKToRGB(c, m, y, k)
	return newColor(r, g, b, a)
}

// Mix mixs both color with the specified weight of the second color. (`0.5` as `50%`)
func (c Color) Mix(color Color, weight float64) Color {
	oWeight := 1 - weight
	r := math.Round(oWeight*c.Red + weight*color.Red)
	g := math.Round(oWeight*c.Green + weight*color.Green)
	b := math.Round(oWeight*c.Blue + weight*color.Blue)
	a := math.Round(oWeight*c.Alpha + weight*color.Alpha)
	return newColor(r, g, b, a)
}

// Hue returns the Hue angle of the current color based on the HSL algorithm.
func (c Color) Hue() float64 {
	h, _, _ := c.HSL()
	return h
}

// Saturation returns the percentage of the current color saturation based on the HSL algorithm.
func (c Color) Saturation() float64 {
	_, s, _ := c.HSL()
	return s
}

// Lightness returns the Lightness of the current color based on the HSL algorithm.
func (c Color) Lightness() float64 {
	_, _, l := c.HSL()
	return l
}

// AdjustHue rotates the Hue angle of the color based on HSL mode, it still goes clockwise if the value was set over than 360 degree.
func (c Color) AdjustHue(degrees float64) Color {
	h, s, l := c.HSL()
	h += degrees
	for {
		if h >= 0 && h <= 360 {
			break
		}
		if h < 0 {
			h += 360
		} else {
			h += -360
		}
	}
	r, g, b := HSLToRGB(h, s, l)
	return newColor(r, g, b, c.Alpha)
}

// Lighten increases the brightness of the color based on HSL mode. (`0.5` as `50%`)
func (c Color) Lighten(percent float64) Color {
	percent = percent * 100
	h, s, l := c.HSL()
	l += percent
	if l > 100 {
		l = 100
	}
	r, g, b := HSLToRGB(h, s, l)
	return newColor(r, g, b, c.Alpha)
}

// Darken decreases the brightness of the color based on HSL mode. (`0.5` as `50%`)
func (c Color) Darken(percent float64) Color {
	percent = percent * 100
	h, s, l := c.HSL()
	l -= percent
	if l < 0 {
		l = 0
	}
	r, g, b := HSLToRGB(h, s, l)
	return newColor(r, g, b, c.Alpha)
}

// Saturate increases the saturation of the color based on HSL mode. (`0.5` as `50%`)
func (c Color) Saturate(percent float64) Color {
	percent = percent * 100
	h, s, l := c.HSL()
	s += percent
	if s > 100 {
		s = 100
	}
	r, g, b := HSLToRGB(h, s, l)
	return newColor(r, g, b, c.Alpha)
}

// Desaturate decreases the saturation of the color based on HSL mode. (`0.5` as `50%`)
func (c Color) Desaturate(percent float64) Color {
	percent = percent * 100
	h, s, l := c.HSL()
	s -= percent
	if s < 0 {
		s = 0
	}
	r, g, b := HSLToRGB(h, s, l)
	return newColor(r, g, b, c.Alpha)
}

// Grayscale converts the color to grayscale, same as `Desaturate(1)`.
func (c Color) Grayscale() Color {
	return c.Desaturate(1)
}

// Complement returns the complementary color of the current color, same as `AdjustHue(180)`.
func (c Color) Complement() Color {
	return c.AdjustHue(180)
}

// Tint increases the brightness of the color while keeping the color tone, same as `Mix` with a white color. (`0.5` as `50%`)
func (c Color) Tint(percent float64) Color {
	return c.Mix(newColor(255, 255, 255, c.Alpha), percent)
}

// Shade decreases the brightness of the color while keeping the color tone, same as `Mix` with a black color. (`0.5` as `50%`)
func (c Color) Shade(percent float64) Color {
	return c.Mix(newColor(0, 0, 0, c.Alpha), percent)
}

// Invert returns the opposite color that based on the RGB color map (it's not a complementary color).
func (c Color) Invert() Color {
	r, g, b := c.RGB()
	r = 255 - r
	g = 255 - g
	b = 255 - b
	return newColor(r, g, b, c.Alpha)
}

// LuminanaceWCAG returns the Luminance of the the current color based on the WCAG 2.0 algorithm.
//
// reference: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
//
// reference: https://medium.com/dev-channel/using-sass-to-automatically-pick-text-colors-4ba7645d2796
func (c Color) LuminanaceWCAG() float64 {
	rgb := []float64{c.Red, c.Green, c.Blue}
	for k, v := range rgb {
		v /= 255
		if v <= 0.03928 {
			v = v / 12.92
		} else {
			v = math.Pow((v+0.055)/1.055, 2.4)
		}
		rgb[k] = v
	}
	v := rgb[0]*0.2126 + rgb[1]*0.7152 + rgb[2]*0.0722
	return math.Round(v*100) / 100
}

// Luminanace returns the Luminance of the current color.
//
// reference: https://en.wikipedia.org/wiki/Relative_luminance
//
// reference: https://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color
//
// reference: https://stackoverflow.com/questions/3116260/given-a-background-color-how-to-get-a-foreground-color-that-makes-it-readable-o
func (c Color) Luminanace() float64 {
	v := 0.2126*c.Red + 0.7152*c.Green + 0.0722*c.Blue
	return math.Round(v*100) / 100
}

// Foreground returns suggested foreground color by calculating the color luminance, it returns a white color when the color is dark, vise versa.
func (c Color) Foreground() Color {
	white := NewRGB(255, 255, 255)
	black := NewRGB(0, 0, 0)
	if c.Luminanace() < 140 {
		return white
	}
	return black
}

// Brighten increases the brightness of the color. (`0.5` as `50%`)
//
// reference: https://github.com/ozdemirburak/iris
func (c Color) Brighten(percent float64) Color {
	percent *= -100
	r := math.Max(0, math.Min(255, c.Red-math.Round(255*(percent/100))))
	g := math.Max(0, math.Min(255, c.Green-math.Round(255*(percent/100))))
	b := math.Max(0, math.Min(255, c.Blue-math.Round(255*(percent/100))))
	return newColor(r, g, b, c.Alpha)
}

// Contrast returns the Contrast of the current color based on the WCAG Luminance algorithm.
func (c Color) Contrast(color Color) float64 {
	c1 := c.LuminanaceWCAG() + 0.05
	c2 := color.LuminanaceWCAG() + 0.05
	v := math.Max(c1, c2) / math.Min(c1, c2)
	return math.Round(v*100) / 100
}

// IsLight returns true if the color is a light scheme, it might not be the same as what human eyes can see.
func (c Color) IsLight() bool {
	darkness := 1 - (0.299*c.Red+0.587*c.Green+0.114*c.Blue)/255
	return darkness < 0.5
}

// IsDark returns true if the color is a dark scheme, it might not be the same as what human eyes can see.
func (c Color) IsDark() bool {
	return !c.IsLight()
}

// HSV returns the HSV value of the current color.
func (c Color) HSV() (float64, float64, float64) {
	return RGBToHSV(c.Red, c.Green, c.Blue)
}

// HSVA returns the HSVA value of the current color.
func (c Color) HSVA() (float64, float64, float64, float64) {
	h, s, v := RGBToHSV(c.Red, c.Green, c.Blue)
	return h, s, v, c.Alpha
}

// HSL returns the HSL value of the current color.
func (c Color) HSL() (float64, float64, float64) {
	return RGBToHSL(c.Red, c.Green, c.Blue)
}

// HSLA returns the HSLA value of the current color.
func (c Color) HSLA() (float64, float64, float64, float64) {
	h, s, l := RGBToHSL(c.Red, c.Green, c.Blue)
	return h, s, l, c.Alpha
}

// RGB returns the RGB value of the current color.
func (c Color) RGB() (float64, float64, float64) {
	return c.Red, c.Green, c.Blue
}

// RGBA returns the RGBA value of the current color.
func (c Color) RGBA() (float64, float64, float64, float64) {
	return c.Red, c.Green, c.Blue, c.Alpha
}

// CMYK returns the CMYK value of the current color.
func (c Color) CMYK() (float64, float64, float64, float64) {
	return RGBToCMYK(c.Red, c.Green, c.Blue)
}

// Hex returns a Hex string of the current color. (Without the `#` prefix)
func (c Color) Hex() string {
	return RGBToHex(c.Red, c.Green, c.Blue)
}

// HTML returns a `#` prefixed Hex string or the HTML color name (like: `red`, `yellow`) if it had one.
// It returns a format with `rgba()` if the color comes with a alpha channel.
func (c Color) HTML() string {
	if c.Alpha != 1 {
		return fmt.Sprintf("rgba(%f, %f, %f, %f)", c.Red, c.Green, c.Blue, c.Alpha)
	}
	return RGBToHTML(c.Red, c.Green, c.Blue)
}