Files
beatglow/internal/_old/pixel/gray.go
T
2026-10-29 17:28:51 +01:00

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