Checkpoint
This commit is contained in:
138 files changed
+1898
-57607
No files matched your search
+82
-346
@@ -3,370 +3,106 @@ package pixel
|
||||
import (
|
||||
"image"
|
||||
"image/color"
|
||||
"image/draw"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// Image buffer, used for working with the native image format of various
|
||||
// displays. It works a lot like a slice: it can be rescaled while reusing the
|
||||
// underlying buffer and should be passed around by value.
|
||||
type Image[T Color] struct {
|
||||
width int16
|
||||
height int16
|
||||
data unsafe.Pointer
|
||||
// VerticalLSB is a 1 bit (black and white) image.
|
||||
//
|
||||
// Each byte is 8 vertical pixels. Each stride is a horizontal band of 8
|
||||
// pixels high with LSB first. So the first byte represents the following
|
||||
// pixels, with lowest bit being the top left pixel.
|
||||
//
|
||||
// 0 x x x x x x x
|
||||
// 1 x x x x x x x
|
||||
// 2 x x x x x x x
|
||||
// 3 x x x x x x x
|
||||
// 4 x x x x x x x
|
||||
// 5 x x x x x x x
|
||||
// 6 x x x x x x x
|
||||
// 7 x x x x x x x
|
||||
//
|
||||
// It is designed specifically to work with SSD1306 OLED display controller.
|
||||
type VerticalLSB struct {
|
||||
// Pix holds the image's pixels, as vertically LSB-first packed bitmap. It
|
||||
// can be passed directly to ssd1306.Dev.Write()
|
||||
Pix []byte
|
||||
// Stride is the Pix stride (in bytes) between vertically adjacent 8 pixels
|
||||
// horizontal bands.
|
||||
Stride int
|
||||
// Rect is the image's bounds.
|
||||
Rect image.Rectangle
|
||||
}
|
||||
|
||||
// NewImage creates a new image of the given size.
|
||||
func NewImage[T Color](width, height int) Image[T] {
|
||||
if width < 0 || height < 0 || int(int16(width)) != width || int(int16(height)) != height {
|
||||
// The width/height are stored as 16-bit integers and should never be
|
||||
// negative.
|
||||
panic("NewImage: width/height out of bounds")
|
||||
}
|
||||
var zeroColor T
|
||||
var data unsafe.Pointer
|
||||
switch {
|
||||
case zeroColor.BitsPerPixel()%8 == 0:
|
||||
// Typical formats like RGB888 and RGB565.
|
||||
// Each color starts at a whole byte offset from the start.
|
||||
buf := make([]T, width*height)
|
||||
data = unsafe.Pointer(&buf[0])
|
||||
default:
|
||||
// Formats like RGB444 that have 12 bits per pixel.
|
||||
// We access these as bytes, so allocate the buffer as a byte slice.
|
||||
bufBits := width * height * zeroColor.BitsPerPixel()
|
||||
bufBytes := (bufBits + 7) / 8
|
||||
buf := make([]byte, bufBytes)
|
||||
data = unsafe.Pointer(&buf[0])
|
||||
}
|
||||
return Image[T]{
|
||||
width: int16(width),
|
||||
height: int16(height),
|
||||
data: data,
|
||||
}
|
||||
// NewVerticalLSB returns an initialized VerticalLSB instance.
|
||||
func NewVerticalLSB(r image.Rectangle) *VerticalLSB {
|
||||
w := r.Dx()
|
||||
// Round down.
|
||||
minY := r.Min.Y &^ 7
|
||||
// Round up.
|
||||
maxY := (r.Max.Y + 7) & ^7
|
||||
bands := (maxY - minY) / 8
|
||||
return &VerticalLSB{Pix: make([]byte, w*bands), Stride: w, Rect: r}
|
||||
}
|
||||
|
||||
// NewImageFromBytes creates a new image of the given size using an existing data slice of bytes.
|
||||
func NewImageFromBytes[T Color](width, height int, buf []byte) Image[T] {
|
||||
if width < 0 || height < 0 || int(int16(width)) != width || int(int16(height)) != height {
|
||||
// The width/height are stored as 16-bit integers and should never be
|
||||
// negative.
|
||||
panic("NewImageFromBytes: width/height out of bounds")
|
||||
}
|
||||
var zeroColor T
|
||||
var data unsafe.Pointer
|
||||
switch {
|
||||
case zeroColor.BitsPerPixel()%8 == 0:
|
||||
// Typical formats like RGB888 and RGB565.
|
||||
// Each color starts at a whole byte offset from the start.
|
||||
if len(buf) != width*height*int(unsafe.Sizeof(zeroColor)) {
|
||||
panic("NewImageFromBytes: data slice size mismatch")
|
||||
}
|
||||
data = unsafe.Pointer(&buf[0])
|
||||
default:
|
||||
// Formats like RGB444 that have 12 bits per pixel.
|
||||
// We access these as bytes, so allocate the buffer as a byte slice.
|
||||
bufBits := width * height * zeroColor.BitsPerPixel()
|
||||
bufBytes := (bufBits + 7) / 8
|
||||
if len(buf) != bufBytes {
|
||||
panic("NewImageFromBytes: data slice size mismatch")
|
||||
}
|
||||
data = unsafe.Pointer(&buf[0])
|
||||
}
|
||||
return Image[T]{
|
||||
width: int16(width),
|
||||
height: int16(height),
|
||||
data: data,
|
||||
}
|
||||
// ColorModel implements image.Image.
|
||||
func (i *VerticalLSB) ColorModel() color.Model {
|
||||
return MonochromeModel
|
||||
}
|
||||
|
||||
// NewImageFromImage creates a new image from the provided image.
|
||||
func NewImageFromImage[T Color](src image.Image) Image[T] {
|
||||
var (
|
||||
r = src.Bounds()
|
||||
width = r.Dx()
|
||||
height = r.Dy()
|
||||
dst = NewImage[T](width, height)
|
||||
)
|
||||
draw.Draw(dst, r, src, image.Point{}, draw.Src)
|
||||
return dst
|
||||
// Bounds implements image.Image.
|
||||
func (i *VerticalLSB) Bounds() image.Rectangle {
|
||||
return i.Rect
|
||||
}
|
||||
|
||||
// Rescale returns a new Image buffer based on the img buffer.
|
||||
// The contents is undefined after the Rescale operation, and any modification
|
||||
// to the returned image will overwrite the underlying image buffer in undefined
|
||||
// ways. It will panic if width*height is larger than img.Len().
|
||||
func (img Image[T]) Rescale(width, height int) Image[T] {
|
||||
if width*height > img.Len() {
|
||||
panic("Image.Rescale size out of bounds")
|
||||
// At implements image.Image.
|
||||
func (i *VerticalLSB) At(x, y int) color.Color {
|
||||
return i.BitAt(x, y)
|
||||
}
|
||||
|
||||
// BitAt is the optimized version of At().
|
||||
func (i *VerticalLSB) BitAt(x, y int) Monochrome {
|
||||
if !(image.Point{x, y}.In(i.Rect)) {
|
||||
return Off
|
||||
}
|
||||
return Image[T]{
|
||||
width: int16(width),
|
||||
height: int16(height),
|
||||
data: img.data,
|
||||
offset, mask := i.PixOffset(x, y)
|
||||
if i.Pix[offset]&mask != 0 {
|
||||
return On
|
||||
}
|
||||
return Off
|
||||
}
|
||||
|
||||
// LimitHeight returns a subimage with the bottom part cut off, as specified by
|
||||
// height.
|
||||
func (img Image[T]) LimitHeight(height int) Image[T] {
|
||||
if height < 0 || height > int(img.height) {
|
||||
panic("Image.LimitHeight: out of bounds")
|
||||
}
|
||||
return Image[T]{
|
||||
width: img.width,
|
||||
height: int16(height),
|
||||
data: img.data,
|
||||
// Opaque scans the entire image and reports whether it is fully opaque.
|
||||
func (i *VerticalLSB) Opaque() bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// PixOffset returns the index of the first element of Pix that corresponds to
|
||||
// the pixel at (x, y) and the corresponding mask.
|
||||
func (i *VerticalLSB) PixOffset(x, y int) (int, byte) {
|
||||
// Adjust band.
|
||||
minY := i.Rect.Min.Y &^ 7
|
||||
pY := (y - minY)
|
||||
offset := pY/8*i.Stride + (x - i.Rect.Min.X)
|
||||
bit := uint(pY & 7)
|
||||
return offset, 1 << bit
|
||||
}
|
||||
|
||||
// Set implements draw.Image
|
||||
func (i *VerticalLSB) Set(x, y int, c color.Color) {
|
||||
if ToGrayBits(c, 1) == 0 {
|
||||
i.SetBit(x, y, Off)
|
||||
}
|
||||
i.SetBit(x, y, On)
|
||||
}
|
||||
|
||||
// Len returns the number of pixels in this image buffer.
|
||||
func (img Image[T]) Len() int {
|
||||
return int(img.width) * int(img.height)
|
||||
}
|
||||
|
||||
// RawBuffer returns a byte slice that can be written directly to the screen
|
||||
// using DrawRGBBitmap8.
|
||||
func (img Image[T]) RawBuffer() []uint8 {
|
||||
var zeroColor T
|
||||
var numBytes int
|
||||
switch {
|
||||
case zeroColor.BitsPerPixel()%8 == 0:
|
||||
// Each color starts at a whole byte offset.
|
||||
numBytes = int(unsafe.Sizeof(zeroColor)) * int(img.width) * int(img.height)
|
||||
default:
|
||||
// Formats like RGB444 that aren't a whole number of bytes.
|
||||
numBits := zeroColor.BitsPerPixel() * int(img.width) * int(img.height)
|
||||
numBytes = (numBits + 7) / 8 // round up (see NewImage)
|
||||
}
|
||||
return unsafe.Slice((*byte)(img.data), numBytes)
|
||||
}
|
||||
|
||||
// Size returns the image size.
|
||||
func (img Image[T]) Size() (int, int) {
|
||||
return int(img.width), int(img.height)
|
||||
}
|
||||
|
||||
func (img Image[T]) setPixel(index int, c T) {
|
||||
var zeroColor T
|
||||
|
||||
switch {
|
||||
case zeroColor.BitsPerPixel() == 1:
|
||||
// Monochrome.
|
||||
offset := index / 8
|
||||
bits := index % 8
|
||||
|
||||
ptr := (*byte)(unsafe.Add(img.data, offset))
|
||||
if c != zeroColor {
|
||||
*((*byte)(ptr)) |= (1 << (7 - uint8(bits)))
|
||||
} else {
|
||||
*((*byte)(ptr)) &^= (1 << (7 - uint8(bits)))
|
||||
}
|
||||
|
||||
return
|
||||
case zeroColor.BitsPerPixel()%8 == 0:
|
||||
// Each color starts at a whole byte offset.
|
||||
// This is the easy case.
|
||||
offset := index * int(unsafe.Sizeof(zeroColor))
|
||||
ptr := unsafe.Add(img.data, offset)
|
||||
*((*T)(ptr)) = c
|
||||
// SetBit is the optimized version of Set().
|
||||
func (i *VerticalLSB) SetBit(x, y int, b Monochrome) {
|
||||
if !(image.Point{x, y}.In(i.Rect)) {
|
||||
return
|
||||
}
|
||||
|
||||
if c, ok := any(c).(RGB444BE); ok {
|
||||
// Special case for RGB444.
|
||||
bitIndex := index * zeroColor.BitsPerPixel()
|
||||
if bitIndex%8 == 0 {
|
||||
byteOffset := bitIndex / 8
|
||||
ptr := (*[2]byte)(unsafe.Add(img.data, byteOffset))
|
||||
ptr[0] = uint8(c >> 4)
|
||||
ptr[1] = ptr[1]&0x0f | uint8(c)<<4 // change top bits
|
||||
} else {
|
||||
byteOffset := bitIndex / 8
|
||||
ptr := (*[2]byte)(unsafe.Add(img.data, byteOffset))
|
||||
ptr[0] = ptr[0]&0xf0 | uint8(c>>8) // change bottom bits
|
||||
ptr[1] = uint8(c)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// TODO: the code for RGB444 should be generalized to support any bit size.
|
||||
panic("todo: setPixel for odd bits per pixel")
|
||||
}
|
||||
|
||||
// Set sets the pixel at x, y to the given color.
|
||||
// Use FillSolidColor to efficiently fill the entire image buffer.
|
||||
func (img Image[T]) SetPixel(x, y int, c T) {
|
||||
if uint(x) >= uint(int(img.width)) || uint(y) >= uint(int(img.height)) {
|
||||
return
|
||||
}
|
||||
index := y*int(img.width) + x
|
||||
img.setPixel(index, c)
|
||||
}
|
||||
|
||||
// Get returns the color at the given index.
|
||||
func (img Image[T]) GetPixel(x, y int) T {
|
||||
var zeroColor T
|
||||
if uint(x) >= uint(int(img.width)) || uint(y) >= uint(int(img.height)) {
|
||||
return zeroColor
|
||||
}
|
||||
index := y*int(img.width) + x // index into img.data
|
||||
|
||||
switch {
|
||||
case zeroColor.BitsPerPixel() == 1:
|
||||
// Monochrome.
|
||||
var c Monochrome
|
||||
offset := index / 8
|
||||
bits := index % 8
|
||||
ptr := (*byte)(unsafe.Add(img.data, offset))
|
||||
c = Monochrome((*ptr >> (7 - uint8(bits))) & 0x1)
|
||||
return any(c).(T)
|
||||
case zeroColor.BitsPerPixel()%8 == 0:
|
||||
// Colors like RGB565, RGB888, etc.
|
||||
offset := index * int(unsafe.Sizeof(zeroColor))
|
||||
ptr := unsafe.Add(img.data, offset)
|
||||
return *((*T)(ptr))
|
||||
}
|
||||
|
||||
if _, ok := any(zeroColor).(RGB444BE); ok {
|
||||
// Special case for RGB444 that isn't stored in a neat byte multiple.
|
||||
bitIndex := index * zeroColor.BitsPerPixel()
|
||||
var c RGB444BE
|
||||
if bitIndex%8 == 0 {
|
||||
byteOffset := bitIndex / 8
|
||||
ptr := (*[2]byte)(unsafe.Add(img.data, byteOffset))
|
||||
c |= RGB444BE(ptr[0]) << 4
|
||||
c |= RGB444BE(ptr[1] >> 4) // load top bits
|
||||
} else {
|
||||
byteOffset := bitIndex / 8
|
||||
ptr := (*[2]byte)(unsafe.Add(img.data, byteOffset))
|
||||
c |= RGB444BE(ptr[0]&0x0f) << 8 // load bottom bits
|
||||
c |= RGB444BE(ptr[1])
|
||||
}
|
||||
return any(c).(T)
|
||||
}
|
||||
|
||||
// TODO: generalize the above code.
|
||||
panic("todo: Image.Get for odd bits per pixel")
|
||||
}
|
||||
|
||||
// FillSolidColor fills the entire image with the given color.
|
||||
// This may be faster than setting individual pixels.
|
||||
func (img Image[T]) FillSolidColor(color T) {
|
||||
var zeroColor T
|
||||
|
||||
switch {
|
||||
case zeroColor.BitsPerPixel() == 1:
|
||||
// Monochrome.
|
||||
var colorByte uint8
|
||||
if color != zeroColor {
|
||||
colorByte = 0xff
|
||||
}
|
||||
numBytes := int(img.width) * int(img.height) / 8
|
||||
for i := 0; i < numBytes; i++ {
|
||||
// TODO: this can be optimized a lot.
|
||||
// - The store can be done as a 32-bit integer, after checking for
|
||||
// alignment.
|
||||
// - Perhaps the loop can be unrolled to improve copy performance.
|
||||
ptr := (*byte)(unsafe.Add(img.data, i))
|
||||
*((*byte)(ptr)) = colorByte
|
||||
}
|
||||
return
|
||||
|
||||
case zeroColor.BitsPerPixel()%8 == 0:
|
||||
// Fast pass for colors of 8, 16, 24, etc bytes in size.
|
||||
ptr := img.data
|
||||
for i := 0; i < img.Len(); i++ {
|
||||
// TODO: this can be optimized a lot.
|
||||
// - The store can be done as a 32-bit integer, after checking for
|
||||
// alignment.
|
||||
// - Perhaps the loop can be unrolled to improve copy performance.
|
||||
*(*T)(ptr) = color
|
||||
ptr = unsafe.Add(ptr, unsafe.Sizeof(zeroColor))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Special case for RGB444.
|
||||
if c, ok := any(color).(RGB444BE); ok {
|
||||
// RGB444 can be stored in a more optimized way, by storing two colors
|
||||
// at a time instead of setting each color individually. This avoids
|
||||
// loading and masking the old color bits for the half-bytes.
|
||||
var buf [3]uint8
|
||||
buf[0] = uint8(c >> 4)
|
||||
buf[1] = uint8(c)<<4 | uint8(c>>8)
|
||||
buf[2] = uint8(c)
|
||||
rawBuf := unsafe.Slice((*[3]byte)(img.data), img.Len()/2)
|
||||
for i := 0; i < len(rawBuf); i++ {
|
||||
rawBuf[i] = buf
|
||||
}
|
||||
if img.Len()%2 != 0 {
|
||||
// The image contains an uneven number of pixels.
|
||||
// This is uncommon, but it can happen and we have to handle it.
|
||||
img.setPixel(img.Len()-1, color)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Fallback for other color formats.
|
||||
for i := 0; i < img.Len(); i++ {
|
||||
img.setPixel(i, color)
|
||||
offset, mask := i.PixOffset(x, y)
|
||||
if b == On {
|
||||
i.Pix[offset] |= mask
|
||||
} else {
|
||||
i.Pix[offset] &^= mask
|
||||
}
|
||||
}
|
||||
|
||||
// At implements the draw.Image interface.
|
||||
func (img Image[T]) At(x, y int) color.Color {
|
||||
return img.GetPixel(x, y)
|
||||
}
|
||||
|
||||
// Set implements the draw.Image interface.
|
||||
func (img Image[T]) Set(x, y int, c color.Color) {
|
||||
var value T
|
||||
switch any(value).(type) {
|
||||
case RGB888:
|
||||
img.SetPixel(x, y, rgb888Model(c).(T))
|
||||
case RGB565BE:
|
||||
img.SetPixel(x, y, rgb565BEModel(c).(T))
|
||||
case RGB555:
|
||||
img.SetPixel(x, y, rgb555Model(c).(T))
|
||||
case RGB444BE:
|
||||
img.SetPixel(x, y, rgb444BEModel(c).(T))
|
||||
case Monochrome:
|
||||
img.SetPixel(x, y, monochromeModel(c).(T))
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
// Bounds returns the image bounding box.
|
||||
func (img Image[T]) Bounds() image.Rectangle {
|
||||
return image.Rect(0, 0, int(img.width), int(img.height))
|
||||
}
|
||||
|
||||
// ColorModel returns the image color model.
|
||||
func (img Image[T]) ColorModel() color.Model {
|
||||
// Ugly cast from color.RGBA to T. The type switch and interface casts are
|
||||
// trivially optimized away after instantiation.
|
||||
var value T
|
||||
switch any(value).(type) {
|
||||
case RGB888:
|
||||
return RGB888Model
|
||||
case RGB565BE:
|
||||
return RGB565BEModel
|
||||
case RGB555:
|
||||
return RGB555Model
|
||||
case RGB444BE:
|
||||
return RGB444BEModel
|
||||
case Monochrome:
|
||||
return MonochromeModel
|
||||
default:
|
||||
panic("unknown color format")
|
||||
}
|
||||
}
|
||||
|
||||
// Clear the image buffer.
|
||||
func (img *Image[T]) Clear() {
|
||||
var zeroColor T
|
||||
img.FillSolidColor(zeroColor)
|
||||
}
|
||||
|
||||
var _ draw.Image = (*Image[RGB888])(nil)
|
||||
Reference in new issue
Block a user