grayscale.go

package xtx

import (
	"image"
	"image/color"
)

// Grayscale is a 2-bit per pixel, 4-level grayscale image corresponding to the
// XTH format. It implements [image.Image] and stores pixels in dual bit-plane
// format with vertical scan order (column-major, right-to-left) matching the
// Xteink e-paper display refresh pattern.
//
// The pixel value mapping follows the non-linear Xteink LUT:
//
//	0 = White, 1 = Dark Grey, 2 = Light Grey, 3 = Black
type Grayscale struct {
	// Pix holds both bit planes concatenated: [plane1][plane2].
	// Each plane uses vertical scan order: columns right-to-left,
	// 8 vertical pixels packed per byte (MSB = topmost).
	Pix []uint8
	// Rect is the image bounds.
	Rect image.Rectangle
	// PlaneSize is the size of one bit plane in bytes.
	PlaneSize int
	// ColBytes is the number of bytes per column: (height + 7) / 8.
	ColBytes int
}

// NewGrayscale creates a new [Grayscale] image with the given bounds.
func NewGrayscale(r image.Rectangle) *Grayscale {
	w, h := r.Dx(), r.Dy()
	colBytes := (h + 7) / 8
	planeSize := w * colBytes
	return &Grayscale{
		Pix:       make([]uint8, planeSize*2),
		Rect:      r,
		PlaneSize: planeSize,
		ColBytes:  colBytes,
	}
}

// ColorModel returns [Gray4Model].
func (img *Grayscale) ColorModel() color.Model {
	return Gray4Model
}

// Bounds returns the image bounds.
func (img *Grayscale) Bounds() image.Rectangle {
	return img.Rect
}

// At returns the color of the pixel at (x, y).
func (img *Grayscale) At(x, y int) color.Color {
	if !(image.Point{x, y}.In(img.Rect)) {
		return Gray4White
	}
	return img.Gray4At(x, y)
}

// Gray4At returns the [Gray4] color at (x, y) without bounds checking.
func (img *Grayscale) Gray4At(x, y int) Gray4 {
	bit1, bit2 := img.getBits(x, y)
	return Gray4{V: (bit1 << 1) | bit2}
}

// Set sets the pixel at (x, y) to color c, converting through [Gray4Model].
func (img *Grayscale) Set(x, y int, c color.Color) {
	if !(image.Point{x, y}.In(img.Rect)) {
		return
	}
	g := Gray4Model.Convert(c).(Gray4)
	img.SetGray4(x, y, g)
}

// SetGray4 sets the pixel at (x, y) to the [Gray4] value without color conversion.
func (img *Grayscale) SetGray4(x, y int, c Gray4) {
	if !(image.Point{x, y}.In(img.Rect)) {
		return
	}
	bit1 := (c.V >> 1) & 1
	bit2 := c.V & 1
	img.setBits(x, y, bit1, bit2)
}

// DataSize returns the total size of the pixel data in bytes (both planes),
// matching the XTH spec: ((width * height + 7) / 8) * 2.
func (img *Grayscale) DataSize() uint32 {
	return uint32(img.PlaneSize * 2)
}

// getBits reads the two bit-plane values for pixel (x, y).
// Vertical scan order: columns scan right-to-left, 8 vertical pixels per byte.
func (img *Grayscale) getBits(x, y int) (bit1, bit2 uint8) {
	// Column index: right to left
	col := img.Rect.Dx() - 1 - x
	byteInCol := y / 8
	bitInByte := 7 - uint(y%8) // MSB = topmost pixel in group

	offset := col*img.ColBytes + byteInCol
	bit1 = (img.Pix[offset] >> bitInByte) & 1
	bit2 = (img.Pix[img.PlaneSize+offset] >> bitInByte) & 1
	return
}

// setBits writes the two bit-plane values for pixel (x, y).
func (img *Grayscale) setBits(x, y int, bit1, bit2 uint8) {
	col := img.Rect.Dx() - 1 - x
	byteInCol := y / 8
	bitInByte := 7 - uint(y%8)

	offset := col*img.ColBytes + byteInCol
	mask := uint8(1) << bitInByte

	// Plane 1 (bit1)
	if bit1 != 0 {
		img.Pix[offset] |= mask
	} else {
		img.Pix[offset] &^= mask
	}

	// Plane 2 (bit2)
	if bit2 != 0 {
		img.Pix[img.PlaneSize+offset] |= mask
	} else {
		img.Pix[img.PlaneSize+offset] &^= mask
	}
}