105 lines
2.2 KiB
Go
105 lines
2.2 KiB
Go
package pixel
|
|
|
|
import (
|
|
"image"
|
|
"image/color"
|
|
)
|
|
|
|
// ToGrayBits converts a color to a n-bit grayscale color.
|
|
func ToGrayBits(c color.Color, n uint8) uint16 {
|
|
r, g, b, _ := c.RGBA()
|
|
|
|
if n < 1 {
|
|
return 0 // no color
|
|
} else if n > 16 {
|
|
n = 16 // most that will fit
|
|
}
|
|
|
|
// Shift values to fit n bits.
|
|
s := 32 - n
|
|
|
|
// These coefficients (the fractions 0.299, 0.587 and 0.114) are the same
|
|
// as those given by the JFIF specification and used by func RGBToYCbCr in
|
|
// image/color/ycbcr.go.
|
|
//
|
|
// Note that 19595 + 38470 + 7471 equals 65536.
|
|
//
|
|
// The 28 is 16 + 8 + n. The 16 is the same as used in RGBToYCbCr. The 8 + n is
|
|
// because the return value is n-bit color, not 16 bit color.
|
|
return uint16((19595*r + 38470*g + 7471*b + 1<<15) >> s)
|
|
}
|
|
|
|
func IsOn(c color.Color) bool {
|
|
return ToGrayBits(c, 1) == 1
|
|
}
|
|
|
|
func IsOff(c color.Color) bool {
|
|
return ToGrayBits(c, 1) == 0
|
|
}
|
|
|
|
// Monochrome is a 1-bit color.
|
|
type Monochrome uint8
|
|
|
|
// Monochrome constants.
|
|
const (
|
|
On Monochrome = iota
|
|
Off
|
|
)
|
|
|
|
func (m Monochrome) RGBA() (r, g, b, a uint32) {
|
|
if m == 0 {
|
|
return 0, 0, 0, 0
|
|
}
|
|
return 0xffff, 0xffff, 0xffff, 0xffff
|
|
}
|
|
|
|
var MonochromeModel color.Model = color.ModelFunc(monochromeModel)
|
|
|
|
func monochromeModel(c color.Color) color.Color {
|
|
if _, ok := c.(Monochrome); ok {
|
|
return c
|
|
}
|
|
if IsOn(c) {
|
|
return Monochrome(1)
|
|
}
|
|
return Monochrome(0)
|
|
}
|
|
|
|
type MonochromeImage struct {
|
|
Pix []byte
|
|
Rect image.Rectangle
|
|
Stride int
|
|
}
|
|
|
|
func NewMonochromeImage(r image.Rectangle) *MonochromeImage {
|
|
var (
|
|
w, h = r.Dx(), r.Dy()
|
|
size = w * h / 8
|
|
pix = make([]byte, size)
|
|
)
|
|
return &MonochromeImage{pix, r, w / 8}
|
|
}
|
|
|
|
func (i *MonochromeImage) ColorModel() color.Model { return MonochromeModel }
|
|
func (i *MonochromeImage) Bounds() image.Rectangle { return i.Rect }
|
|
|
|
func (i *MonochromeImage) At(x, y int) color.Color {
|
|
if !(image.Point{x, y}.In(i.Rect)) {
|
|
return Monochrome(0)
|
|
}
|
|
o := y*i.Stride + x/8
|
|
return Monochrome(i.Pix[o] >> (7 - uint(x%8)) & 1)
|
|
}
|
|
|
|
func (i *MonochromeImage) Set(x, y int, c color.Color) {
|
|
if !(image.Point{x, y}.In(i.Rect)) {
|
|
return
|
|
}
|
|
o := y*i.Stride + x/8
|
|
if IsOn(c) {
|
|
i.Pix[o] |= 1 << (7 - uint(x%8))
|
|
} else {
|
|
i.Pix[o] &^= 1 << (7 - uint(x%8))
|
|
}
|
|
}
|