func (c attrColor) RGBA() (r, g, b, a uint32) {
switch termbox.Attribute(c) {
case termbox.ColorBlack:
return 0, 0, 0, math.MaxUint16
case termbox.ColorRed:
return math.MaxUint16, 0, 0, math.MaxUint16
case termbox.ColorGreen:
return 0, math.MaxUint16, 0, math.MaxUint16
case termbox.ColorYellow:
return math.MaxUint16, math.MaxUint16, 0, math.MaxUint16
case termbox.ColorBlue:
return 0, 0, math.MaxUint16, math.MaxUint16
case termbox.ColorMagenta:
return math.MaxUint16, 0, math.MaxUint16, math.MaxUint16
case termbox.ColorCyan:
return 0, math.MaxUint16, math.MaxUint16, math.MaxUint16
case termbox.ColorWhite:
return math.MaxUint16, math.MaxUint16, math.MaxUint16, math.MaxUint16
}
switch {
case c >= 16 && c <= 231:
c -= 16
rgba := color.RGBA{R: base[(c/36)%6], G: base[(c/6)%6], B: base[c%6], A: 0xff}
return rgba.RGBA()
case c >= 232 && c <= 255:
x := uint8(0x08 + 0xa*(c-232))
rgba := color.RGBA{R: x, G: x, B: x, A: 0xff}
return rgba.RGBA()
}
panic("not found")
}
func (s *S) TestColor(c *check.C) {
for r := 0; r < 256; r += 5 {
for g := 0; g < 256; g += 5 {
for b := 0; b < 256; b += 5 {
col := color.RGBA{uint8(r), uint8(g), uint8(b), 0}
cDirectR, cDirectG, cDirectB, cDirectA := col.RGBA()
hsva := RGBAtoHSVA(col.RGBA())
c.Check(hsva.H, floatWithinRange, float64(0), float64(360))
c.Check(hsva.S, floatWithinRange, float64(0), float64(1))
c.Check(hsva.V, floatWithinRange, float64(0), float64(1))
cFromHSVR, cFromHSVG, cFromHSVB, cFromHSVA := hsva.RGBA()
c.Check(cFromHSVR, uintWithinRange, uint32(0), uint32(0xFFFF))
c.Check(cFromHSVG, uintWithinRange, uint32(0), uint32(0xFFFF))
c.Check(cFromHSVB, uintWithinRange, uint32(0), uint32(0xFFFF))
back := RGBAtoHSVA(color.RGBA{uint8(cFromHSVR >> 8), uint8(cFromHSVG >> 8), uint8(cFromHSVB >> 8), uint8(cFromHSVA)}.RGBA())
c.Check(hsva, check.Equals, back)
c.Check(cFromHSVR, withinEpsilon, cDirectR, e)
c.Check(cFromHSVG, withinEpsilon, cDirectG, e)
c.Check(cFromHSVB, withinEpsilon, cDirectB, e)
c.Check(cFromHSVA, check.Equals, cDirectA)
if c.Failed() {
return
}
}
}
}
}
func TestColor(t *testing.T) {
for r := 0; r < 256; r += 5 {
for g := 0; g < 256; g += 5 {
for b := 0; b < 256; b += 5 {
col := color.RGBA{uint8(r), uint8(g), uint8(b), 0}
cDirectR, cDirectG, cDirectB, cDirectA := col.RGBA()
hsva := rgbaToHsva(col.RGBA())
if hsva.H < 0 || hsva.H > 1 {
t.Errorf("unexpected values for H: want [0, 1] got:%f", hsva.H)
}
if hsva.S < 0 || hsva.S > 1 {
t.Errorf("unexpected values for S: want [0, 1] got:%f", hsva.S)
}
if hsva.V < 0 || hsva.V > 1 {
t.Errorf("unexpected values for V: want [0, 1] got:%f", hsva.V)
}
cFromHSVR, cFromHSVG, cFromHSVB, cFromHSVA := hsva.RGBA()
if cFromHSVR < 0 || cFromHSVR > 0xFFFF {
t.Errorf("unexpected values for H: want [0x0, 0xFFFF] got:%f", hsva.H)
}
if cFromHSVG < 0 || cFromHSVG > 0xFFFF {
t.Errorf("unexpected values for S: want [0x0, 0xFFFF] got:%f", hsva.S)
}
if cFromHSVB < 0 || cFromHSVB > 0xFFFF {
t.Errorf("unexpected values for V: want [0x0, 0xFFFF] got:%f", hsva.V)
}
if cFromHSVA < 0 || cFromHSVA > 0xFFFF {
t.Errorf("unexpected values for V: want [0x0, 0xFFFF] got:%f", hsva.V)
}
back := rgbaToHsva(color.RGBA{uint8(cFromHSVR >> 8), uint8(cFromHSVG >> 8), uint8(cFromHSVB >> 8), uint8(cFromHSVA)}.RGBA())
if hsva != back {
t.Errorf("roundtrip error: got:%#v want:%#v", back, hsva)
}
const epsilon = 1
if !withinEpsilon(cFromHSVR, cDirectR, epsilon) {
t.Errorf("roundtrip error for R: got:%d want:%d", cFromHSVR, cDirectR)
}
if !withinEpsilon(cFromHSVG, cDirectG, epsilon) {
t.Errorf("roundtrip error for G: got:%d want:%d %d", cFromHSVG, cDirectG, cFromHSVG-cDirectG)
}
if !withinEpsilon(cFromHSVB, cDirectB, epsilon) {
t.Errorf("roundtrip error for B: got:%d want:%d", cFromHSVB, cDirectB)
}
if cFromHSVA != cDirectA {
t.Errorf("roundtrip error for A: got:%d want:%d", cFromHSVA, cDirectA)
}
if t.Failed() {
return
}
}
}
}
}
func DistanceBetweenColors(color1, color2 color.RGBA) float64 {
r1, g1, b1, _ := color1.RGBA()
r2, g2, b2, _ := color2.RGBA()
rDiff := math.Pow(lolDiff(r1, r2), 2.0)
gDiff := math.Pow(lolDiff(g1, g2), 2.0)
bDiff := math.Pow(lolDiff(b1, b2), 2.0)
sum := rDiff + gDiff + bDiff
return math.Sqrt(sum)
}
func plot(img *image.RGBA, x, y int, c *color.RGBA) {
r0, g0, b0, a0 := img.At(x, y).RGBA() // background color
r1, g1, b1, a1 := c.RGBA() // foreground color
var alpha0 float64 = float64(a0) / float64(0xff) // background alpha
var alpha1 float64 = float64(a1) / float64(0xff) // foreground alpha
// resulting colors
var r uint8 = uint8(alpha1*float64(r1) + (1.0-alpha1)*float64(r0))
var g uint8 = uint8(alpha1*float64(g1) + (1.0-alpha1)*float64(g0))
var b uint8 = uint8(alpha1*float64(b1) + (1.0-alpha1)*float64(b0))
var a uint8 = uint8(0xff * (alpha1 + alpha0*(1.0-alpha1)))
pxl := color.RGBA{r, g, b, a} // resulting pixel
img.Set(x, y, pxl)
}
func TestWritePng(t *testing.T) {
img1 := NewImage(100, 100)
col1 := color.RGBA{0, 11, 0, 255}
img1.DrawDot(4, 5, col1)
var buf bytes.Buffer
img1.WritePng(&buf)
img2, _ := png.Decode(&buf)
col2 := img2.At(4, 5)
_, r1, _, _ := col1.RGBA()
_, r2, _, _ := col2.RGBA()
if r2 != r1 {
t.Errorf("expected '%v' but got '%v'", r1, r2)
}
}
func adjustColor(ca color.RGBA, cb color.Color, n uint8) color.RGBA {
r, g, b, a := ca.RGBA()
retR := uint8(r)
retG := uint8(g)
retB := uint8(b)
retA := uint8(a)
r, g, b, a = cb.RGBA()
retR += uint8(r) / n
retG += uint8(g) / n
retB += uint8(b) / n
retA += uint8(a) / n
return color.RGBA{retR, retG, retB, retA}
}
func TestColor(t *testing.T) {
baseColor := color.RGBA{251, 252, 253, 254}
hex := ColorToHexString(baseColor)
n, _ := strconv.ParseInt(hex, 0, 64)
f64 := ColorToFloat64(baseColor)
if n != int64(f64) {
t.Fatal("Color convertion not equal ?")
}
recolor := Float64ToColor(f64)
r, g, b, _ := baseColor.RGBA()
rr, rg, rb, _ := recolor.RGBA()
if rr != r || rg != g || rb != b {
t.Fatal("Cant convert back to color !, ", rr, r, rg, g, rb, b)
}
}
// SetColor sets the fore color of the window.
func (win *window) SetColor(p sparta.Property, c color.RGBA) {
if (p != sparta.Background) && (p != sparta.Foreground) {
return
}
s := xwin.DefaultScreen()
code := getColorCode(c)
px, ok := pixelMap[code]
if !ok {
r, g, b, _ := c.RGBA()
cl, _ := xwin.AllocColor(s.DefaultColormap, uint16(r), uint16(g), uint16(b))
px = cl.Pixel
pixelMap[code] = px
}
if p == sparta.Foreground {
xwin.ChangeGC(win.gc, xgb.GCForeground, []uint32{px})
} else {
xwin.ChangeGC(win.gc, xgb.GCBackground, []uint32{px})
}
}
func Lighter(c color.RGBA, s float64) color.RGBA {
if s == 1 {
return c
}
if s < 1 {
return MixColors(c, color.RGBA{0, 0, 0, 255}, 1-s)
} else {
return MixColors(c, color.RGBA{255, 255, 255, 255}, s-1)
}
if (c == color.RGBA{0, 0, 0, 255}) {
if s < 1 {
return color.RGBA{0x05, 0x05, 0x20, 255}
} else {
return color.RGBA{0x10, 0x10, 0x30, 255}
}
}
if s > 1 && (c == color.RGBA{0xff, 0xff, 0xff, 255}) {
return color.RGBA{0xdf, 0xdf, 0xff, 255}
}
r1, g1, b1, a1 := c.RGBA()
cl := make([]uint8, 4)
for i, n := range []uint32{r1, g1, b1, a1} {
if i == 3 {
cl[i] = uint8(n)
continue
}
x := float64(uint8(n)) * s
if x > 255 {
x = 255
}
if x == 0 && s > 1 {
x = 255. * (s - 1)
}
cl[i] = uint8(x)
}
return color.RGBA{R: cl[0], G: cl[1], B: cl[2], A: cl[3]}
}
