← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/pkg/image/color.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-04-20 17:36:48 UTC
  • Revision ID: james.westby@ubuntu.com-20110420173648-ifergoxyrm832trd
Tags: upstream-2011.03.07.1
Import upstream version 2011.03.07.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/image/color.go
 
1
// Copyright 2009 The Go Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package image
 
6
 
 
7
// All Colors can convert themselves, with a possible loss of precision,
 
8
// to 64-bit alpha-premultiplied RGBA. Each channel value ranges within
 
9
// [0, 0xFFFF].
 
10
type Color interface {
 
11
        RGBA() (r, g, b, a uint32)
 
12
}
 
13
 
 
14
// An RGBAColor represents a traditional 32-bit alpha-premultiplied color,
 
15
// having 8 bits for each of red, green, blue and alpha.
 
16
type RGBAColor struct {
 
17
        R, G, B, A uint8
 
18
}
 
19
 
 
20
func (c RGBAColor) RGBA() (r, g, b, a uint32) {
 
21
        r = uint32(c.R)
 
22
        r |= r << 8
 
23
        g = uint32(c.G)
 
24
        g |= g << 8
 
25
        b = uint32(c.B)
 
26
        b |= b << 8
 
27
        a = uint32(c.A)
 
28
        a |= a << 8
 
29
        return
 
30
}
 
31
 
 
32
// An RGBA64Color represents a 64-bit alpha-premultiplied color,
 
33
// having 16 bits for each of red, green, blue and alpha.
 
34
type RGBA64Color struct {
 
35
        R, G, B, A uint16
 
36
}
 
37
 
 
38
func (c RGBA64Color) RGBA() (r, g, b, a uint32) {
 
39
        return uint32(c.R), uint32(c.G), uint32(c.B), uint32(c.A)
 
40
}
 
41
 
 
42
// An NRGBAColor represents a non-alpha-premultiplied 32-bit color.
 
43
type NRGBAColor struct {
 
44
        R, G, B, A uint8
 
45
}
 
46
 
 
47
func (c NRGBAColor) RGBA() (r, g, b, a uint32) {
 
48
        r = uint32(c.R)
 
49
        r |= r << 8
 
50
        r *= uint32(c.A)
 
51
        r /= 0xff
 
52
        g = uint32(c.G)
 
53
        g |= g << 8
 
54
        g *= uint32(c.A)
 
55
        g /= 0xff
 
56
        b = uint32(c.B)
 
57
        b |= b << 8
 
58
        b *= uint32(c.A)
 
59
        b /= 0xff
 
60
        a = uint32(c.A)
 
61
        a |= a << 8
 
62
        return
 
63
}
 
64
 
 
65
// An NRGBA64Color represents a non-alpha-premultiplied 64-bit color,
 
66
// having 16 bits for each of red, green, blue and alpha.
 
67
type NRGBA64Color struct {
 
68
        R, G, B, A uint16
 
69
}
 
70
 
 
71
func (c NRGBA64Color) RGBA() (r, g, b, a uint32) {
 
72
        r = uint32(c.R)
 
73
        r *= uint32(c.A)
 
74
        r /= 0xffff
 
75
        g = uint32(c.G)
 
76
        g *= uint32(c.A)
 
77
        g /= 0xffff
 
78
        b = uint32(c.B)
 
79
        b *= uint32(c.A)
 
80
        b /= 0xffff
 
81
        a = uint32(c.A)
 
82
        return
 
83
}
 
84
 
 
85
// An AlphaColor represents an 8-bit alpha.
 
86
type AlphaColor struct {
 
87
        A uint8
 
88
}
 
89
 
 
90
func (c AlphaColor) RGBA() (r, g, b, a uint32) {
 
91
        a = uint32(c.A)
 
92
        a |= a << 8
 
93
        return a, a, a, a
 
94
}
 
95
 
 
96
// An Alpha16Color represents a 16-bit alpha.
 
97
type Alpha16Color struct {
 
98
        A uint16
 
99
}
 
100
 
 
101
func (c Alpha16Color) RGBA() (r, g, b, a uint32) {
 
102
        a = uint32(c.A)
 
103
        return a, a, a, a
 
104
}
 
105
 
 
106
// A GrayColor represents an 8-bit grayscale color.
 
107
type GrayColor struct {
 
108
        Y uint8
 
109
}
 
110
 
 
111
func (c GrayColor) RGBA() (r, g, b, a uint32) {
 
112
        y := uint32(c.Y)
 
113
        y |= y << 8
 
114
        return y, y, y, 0xffff
 
115
}
 
116
 
 
117
// A Gray16Color represents a 16-bit grayscale color.
 
118
type Gray16Color struct {
 
119
        Y uint16
 
120
}
 
121
 
 
122
func (c Gray16Color) RGBA() (r, g, b, a uint32) {
 
123
        y := uint32(c.Y)
 
124
        return y, y, y, 0xffff
 
125
}
 
126
 
 
127
// A ColorModel can convert foreign Colors, with a possible loss of precision,
 
128
// to a Color from its own color model.
 
129
type ColorModel interface {
 
130
        Convert(c Color) Color
 
131
}
 
132
 
 
133
// The ColorModelFunc type is an adapter to allow the use of an ordinary
 
134
// color conversion function as a ColorModel.  If f is such a function,
 
135
// ColorModelFunc(f) is a ColorModel object that invokes f to implement
 
136
// the conversion.
 
137
type ColorModelFunc func(Color) Color
 
138
 
 
139
func (f ColorModelFunc) Convert(c Color) Color {
 
140
        return f(c)
 
141
}
 
142
 
 
143
func toRGBAColor(c Color) Color {
 
144
        if _, ok := c.(RGBAColor); ok {
 
145
                return c
 
146
        }
 
147
        r, g, b, a := c.RGBA()
 
148
        return RGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), uint8(a >> 8)}
 
149
}
 
150
 
 
151
func toRGBA64Color(c Color) Color {
 
152
        if _, ok := c.(RGBA64Color); ok {
 
153
                return c
 
154
        }
 
155
        r, g, b, a := c.RGBA()
 
156
        return RGBA64Color{uint16(r), uint16(g), uint16(b), uint16(a)}
 
157
}
 
158
 
 
159
func toNRGBAColor(c Color) Color {
 
160
        if _, ok := c.(NRGBAColor); ok {
 
161
                return c
 
162
        }
 
163
        r, g, b, a := c.RGBA()
 
164
        if a == 0xffff {
 
165
                return NRGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), 0xff}
 
166
        }
 
167
        if a == 0 {
 
168
                return NRGBAColor{0, 0, 0, 0}
 
169
        }
 
170
        // Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
 
171
        r = (r * 0xffff) / a
 
172
        g = (g * 0xffff) / a
 
173
        b = (b * 0xffff) / a
 
174
        return NRGBAColor{uint8(r >> 8), uint8(g >> 8), uint8(b >> 8), uint8(a >> 8)}
 
175
}
 
176
 
 
177
func toNRGBA64Color(c Color) Color {
 
178
        if _, ok := c.(NRGBA64Color); ok {
 
179
                return c
 
180
        }
 
181
        r, g, b, a := c.RGBA()
 
182
        if a == 0xffff {
 
183
                return NRGBA64Color{uint16(r), uint16(g), uint16(b), 0xffff}
 
184
        }
 
185
        if a == 0 {
 
186
                return NRGBA64Color{0, 0, 0, 0}
 
187
        }
 
188
        // Since Color.RGBA returns a alpha-premultiplied color, we should have r <= a && g <= a && b <= a.
 
189
        r = (r * 0xffff) / a
 
190
        g = (g * 0xffff) / a
 
191
        b = (b * 0xffff) / a
 
192
        return NRGBA64Color{uint16(r), uint16(g), uint16(b), uint16(a)}
 
193
}
 
194
 
 
195
func toAlphaColor(c Color) Color {
 
196
        if _, ok := c.(AlphaColor); ok {
 
197
                return c
 
198
        }
 
199
        _, _, _, a := c.RGBA()
 
200
        return AlphaColor{uint8(a >> 8)}
 
201
}
 
202
 
 
203
func toAlpha16Color(c Color) Color {
 
204
        if _, ok := c.(Alpha16Color); ok {
 
205
                return c
 
206
        }
 
207
        _, _, _, a := c.RGBA()
 
208
        return Alpha16Color{uint16(a)}
 
209
}
 
210
 
 
211
func toGrayColor(c Color) Color {
 
212
        if _, ok := c.(GrayColor); ok {
 
213
                return c
 
214
        }
 
215
        r, g, b, _ := c.RGBA()
 
216
        y := (299*r + 587*g + 114*b + 500) / 1000
 
217
        return GrayColor{uint8(y >> 8)}
 
218
}
 
219
 
 
220
func toGray16Color(c Color) Color {
 
221
        if _, ok := c.(Gray16Color); ok {
 
222
                return c
 
223
        }
 
224
        r, g, b, _ := c.RGBA()
 
225
        y := (299*r + 587*g + 114*b + 500) / 1000
 
226
        return Gray16Color{uint16(y)}
 
227
}
 
228
 
 
229
// The ColorModel associated with RGBAColor.
 
230
var RGBAColorModel ColorModel = ColorModelFunc(toRGBAColor)
 
231
 
 
232
// The ColorModel associated with RGBA64Color.
 
233
var RGBA64ColorModel ColorModel = ColorModelFunc(toRGBA64Color)
 
234
 
 
235
// The ColorModel associated with NRGBAColor.
 
236
var NRGBAColorModel ColorModel = ColorModelFunc(toNRGBAColor)
 
237
 
 
238
// The ColorModel associated with NRGBA64Color.
 
239
var NRGBA64ColorModel ColorModel = ColorModelFunc(toNRGBA64Color)
 
240
 
 
241
// The ColorModel associated with AlphaColor.
 
242
var AlphaColorModel ColorModel = ColorModelFunc(toAlphaColor)
 
243
 
 
244
// The ColorModel associated with Alpha16Color.
 
245
var Alpha16ColorModel ColorModel = ColorModelFunc(toAlpha16Color)
 
246
 
 
247
// The ColorModel associated with GrayColor.
 
248
var GrayColorModel ColorModel = ColorModelFunc(toGrayColor)
 
249
 
 
250
// The ColorModel associated with Gray16Color.
 
251
var Gray16ColorModel ColorModel = ColorModelFunc(toGray16Color)