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]} }