mirror of
https://github.com/golang/go
synced 2024-11-24 22:57:57 -07:00
image: delete obsolete color.go
I accidentally left it off of https://golang.org/cl/5132048/. R=r CC=golang-dev https://golang.org/cl/5202042
This commit is contained in:
Nigel Tao
parent
5782ea9646
commit
af2070598f
@ -1,251 +0,0 @@
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package image
|
||||
|
||||
// Color can convert itself to alpha-premultiplied RGBA, with a possible loss
|
||||
// of precision. Each value ranges within [0, 0xFFFF], but is represented by a
|
||||
// uint32 so that multiplying by a blend factor up to 0xFFFF will not overflow.
|
||||
type Color interface {
|
||||
RGBA() (r, g, b, a uint32)
|
||||
}
|
||||
|
||||
// RGBAColor represents a traditional 32-bit alpha-premultiplied color,
|
||||
// having 8 bits for each of red, green, blue and alpha.
|
||||
type RGBAColor struct {
|
||||
R, G, B, A uint8
|
||||
}
|
||||
|
||||
func (c RGBAColor) RGBA() (r, g, b, a uint32) {
|
||||
r = uint32(c.R)
|
||||
r |= r << 8
|
||||
g = uint32(c.G)
|
||||
g |= g << 8
|
||||
b = uint32(c.B)
|
||||
b |= b << 8
|
||||
a = uint32(c.A)
|
||||
a |= a << 8
|
||||
return
|
||||
}
|
||||
|
||||
// RGBA64Color represents a 64-bit alpha-premultiplied color,
|
||||
// having 16 bits for each of red, green, blue and alpha.
|
||||
type RGBA64Color struct {
|
||||
R, G, B, A uint16
|
||||
}
|
||||
|
||||
func (c RGBA64Color) RGBA() (r, g, b, a uint32) {
|
||||
return uint32(c.R), uint32(c.G), uint32(c.B), uint32(c.A)
|
||||
}
|
||||
|
||||
// NRGBAColor represents a non-alpha-premultiplied 32-bit color.
|
||||
type NRGBAColor struct {
|
||||
R, G, B, A uint8
|
||||
}
|
||||
|
||||
func (c NRGBAColor) RGBA() (r, g, b, a uint32) {
|
||||
r = uint32(c.R)
|
||||
r |= r << 8
|
||||
r *= uint32(c.A)
|
||||
r /= 0xff
|
||||
g = uint32(c.G)
|
||||
g |= g << 8
|
||||
g *= uint32(c.A)
|
||||
g /= 0xff
|
||||
b = uint32(c.B)
|
||||
b |= b << 8
|
||||
b *= uint32(c.A)
|
||||
b /= 0xff
|
||||
a = uint32(c.A)
|
||||
a |= a << 8
|
||||
return
|
||||
}
|
||||
|
||||
// NRGBA64Color represents a non-alpha-premultiplied 64-bit color,
|
||||
// having 16 bits for each of red, green, blue and alpha.
|
||||
type NRGBA64Color struct {
|
||||
R, G, B, A uint16
|
||||
}
|
||||
|
||||
func (c NRGBA64Color) RGBA() (r, g, b, a uint32) {
|
||||
r = uint32(c.R)
|
||||
r *= uint32(c.A)
|
||||
r /= 0xffff
|
||||
g = uint32(c.G)
|
||||
g *= uint32(c.A)
|
||||
g /= 0xffff
|
||||
b = uint32(c.B)
|
||||
b *= uint32(c.A)
|
||||
b /= 0xffff
|
||||
a = uint32(c.A)
|
||||
return
|
||||
}
|
||||
|
||||
// AlphaColor represents an 8-bit alpha.
|
||||
type AlphaColor struct {
|
||||
A uint8
|
||||
}
|
||||
|
||||
func (c AlphaColor) RGBA() (r, g, b, a uint32) {
|
||||
a = uint32(c.A)
|
||||
a |= a << 8
|
||||
return a, a, a, a
|
||||
}
|
||||
|
||||
// Alpha16Color represents a 16-bit alpha.
|
||||
type Alpha16Color struct {
|
||||
A uint16
|
||||
}
|
||||
|
||||
func (c Alpha16Color) RGBA() (r, g, b, a uint32) {
|
||||
a = uint32(c.A)
|
||||
return a, a, a, a
|
||||
}
|
||||
|
||||
// GrayColor represents an 8-bit grayscale color.
|
||||
type GrayColor struct {
|
||||
Y uint8
|
||||
}
|
||||
|
||||
func (c GrayColor) RGBA() (r, g, b, a uint32) {
|
||||
y := uint32(c.Y)
|
||||
y |= y << 8
|
||||
return y, y, y, 0xffff
|
||||
}
|
||||
|
||||
// Gray16Color represents a 16-bit grayscale color.
|
||||
type Gray16Color struct {
|
||||
Y uint16
|
||||
}
|
||||
|
||||
func (c Gray16Color) RGBA() (r, g, b, a uint32) {
|
||||
y := uint32(c.Y)
|
||||
return y, y, y, 0xffff
|
||||
}
|
||||
|
||||
// ColorModel can convert foreign Colors, with a possible loss of precision,
|
||||
// to a Color from its own color model.
|
||||
type ColorModel interface {
|
||||
Convert(c Color) Color
|
||||
}
|
||||
|
||||
// The ColorModelFunc type is an adapter to allow the use of an ordinary
|
||||
// color conversion function as a ColorModel. If f is such a function,
|
||||
// ColorModelFunc(f) is a ColorModel object that invokes f to implement
|
||||
// the conversion.
|
||||
type ColorModelFunc func(Color) Color
|
||||
|
||||
func (f ColorModelFunc) Convert(c Color) Color {
|
||||
return f(c)
|
||||
}
|
||||
|
||||
func toRGBAColor(c Color) Color {
|
||||
if _, ok := c.(RGBAColor); ok {
|
||||
return c
|
||||
}
|
||||
r, g, b, a := c.RGBA()
|
||||
return RGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), uint8(a >> 8)}
|
||||
}
|
||||
|
||||
func toRGBA64Color(c Color) Color {
|
||||
if _, ok := c.(RGBA64Color); ok {
|
||||
return c
|
||||
}
|
||||
r, g, b, a := c.RGBA()
|
||||
return RGBA64Color{uint16(r), uint16(g), uint16(b), uint16(a)}
|
||||
}
|
||||
|
||||
func toNRGBAColor(c Color) Color {
|
||||
if _, ok := c.(NRGBAColor); ok {
|
||||
return c
|
||||
}
|
||||
r, g, b, a := c.RGBA()
|
||||
if a == 0xffff {
|
||||
return NRGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), 0xff}
|
||||
}
|
||||
if a == 0 {
|
||||
return NRGBAColor{0, 0, 0, 0}
|
||||
}
|
||||
// Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
|
||||
r = (r * 0xffff) / a
|
||||
g = (g * 0xffff) / a
|
||||
b = (b * 0xffff) / a
|
||||
return NRGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), uint8(a >> 8)}
|
||||
}
|
||||
|
||||
func toNRGBA64Color(c Color) Color {
|
||||
if _, ok := c.(NRGBA64Color); ok {
|
||||
return c
|
||||
}
|
||||
r, g, b, a := c.RGBA()
|
||||
if a == 0xffff {
|
||||
return NRGBA64Color{uint16(r), uint16(g), uint16(b), 0xffff}
|
||||
}
|
||||
if a == 0 {
|
||||
return NRGBA64Color{0, 0, 0, 0}
|
||||
}
|
||||
// Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
|
||||
r = (r * 0xffff) / a
|
||||
g = (g * 0xffff) / a
|
||||
b = (b * 0xffff) / a
|
||||
return NRGBA64Color{uint16(r), uint16(g), uint16(b), uint16(a)}
|
||||
}
|
||||
|
||||
func toAlphaColor(c Color) Color {
|
||||
if _, ok := c.(AlphaColor); ok {
|
||||
return c
|
||||
}
|
||||
_, _, _, a := c.RGBA()
|
||||
return AlphaColor{uint8(a >> 8)}
|
||||
}
|
||||
|
||||
func toAlpha16Color(c Color) Color {
|
||||
if _, ok := c.(Alpha16Color); ok {
|
||||
return c
|
||||
}
|
||||
_, _, _, a := c.RGBA()
|
||||
return Alpha16Color{uint16(a)}
|
||||
}
|
||||
|
||||
func toGrayColor(c Color) Color {
|
||||
if _, ok := c.(GrayColor); ok {
|
||||
return c
|
||||
}
|
||||
r, g, b, _ := c.RGBA()
|
||||
y := (299*r + 587*g + 114*b + 500) / 1000
|
||||
return GrayColor{uint8(y >> 8)}
|
||||
}
|
||||
|
||||
func toGray16Color(c Color) Color {
|
||||
if _, ok := c.(Gray16Color); ok {
|
||||
return c
|
||||
}
|
||||
r, g, b, _ := c.RGBA()
|
||||
y := (299*r + 587*g + 114*b + 500) / 1000
|
||||
return Gray16Color{uint16(y)}
|
||||
}
|
||||
|
||||
// The ColorModel associated with RGBAColor.
|
||||
var RGBAColorModel ColorModel = ColorModelFunc(toRGBAColor)
|
||||
|
||||
// The ColorModel associated with RGBA64Color.
|
||||
var RGBA64ColorModel ColorModel = ColorModelFunc(toRGBA64Color)
|
||||
|
||||
// The ColorModel associated with NRGBAColor.
|
||||
var NRGBAColorModel ColorModel = ColorModelFunc(toNRGBAColor)
|
||||
|
||||
// The ColorModel associated with NRGBA64Color.
|
||||
var NRGBA64ColorModel ColorModel = ColorModelFunc(toNRGBA64Color)
|
||||
|
||||
// The ColorModel associated with AlphaColor.
|
||||
var AlphaColorModel ColorModel = ColorModelFunc(toAlphaColor)
|
||||
|
||||
// The ColorModel associated with Alpha16Color.
|
||||
var Alpha16ColorModel ColorModel = ColorModelFunc(toAlpha16Color)
|
||||
|
||||
// The ColorModel associated with GrayColor.
|
||||
var GrayColorModel ColorModel = ColorModelFunc(toGrayColor)
|
||||
|
||||
// The ColorModel associated with Gray16Color.
|
||||
var Gray16ColorModel ColorModel = ColorModelFunc(toGray16Color)
|
||||
Loading…
Reference in New Issue
Block a user