Created an Image type.
This commit is contained in:
parent
299a2b9c9d
commit
cee2a11c1a
164
image.go
Normal file
164
image.go
Normal file
@ -0,0 +1,164 @@
|
|||||||
|
package oklab
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"image"
|
||||||
|
"image/color"
|
||||||
|
"image/draw"
|
||||||
|
"math"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Not many images can say they have 256-bit color;
|
||||||
|
// I've definitely gone overboard with this.
|
||||||
|
const bytesPerPixel = 8 * 4
|
||||||
|
|
||||||
|
// Image represents an image that encodes its pixels using OKLab color.
|
||||||
|
//
|
||||||
|
// Each pixel is 32 bytes in size, encoding the Lightness, ChromaA, ChromaB, and Alpha components
|
||||||
|
// of each pixel in that order as big-endian float64 values.
|
||||||
|
type Image struct {
|
||||||
|
Pix []uint8
|
||||||
|
Stride int
|
||||||
|
Rect image.Rectangle
|
||||||
|
}
|
||||||
|
|
||||||
|
// ColorModel implements the [image.Image] interface.
|
||||||
|
func (p *Image) ColorModel() color.Model {
|
||||||
|
return Model
|
||||||
|
}
|
||||||
|
|
||||||
|
// Bounds implements the [image.Image] interface.
|
||||||
|
func (p *Image) Bounds() image.Rectangle {
|
||||||
|
return p.Rect
|
||||||
|
}
|
||||||
|
|
||||||
|
// At implements the [image.Image] interface.
|
||||||
|
func (p *Image) At(x, y int) color.Color {
|
||||||
|
return p.OkLabAt(x, y)
|
||||||
|
}
|
||||||
|
|
||||||
|
// RGBA64At implements the [image.RGBA64Image] interface.
|
||||||
|
func (p *Image) RGBA64At(x, y int) color.RGBA64 {
|
||||||
|
r, g, b, a := p.OkLabAt(x, y).RGBA()
|
||||||
|
return color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)}
|
||||||
|
}
|
||||||
|
|
||||||
|
// OkLabAt decodes the pixel at the given coordinates into an OkLab color.
|
||||||
|
//
|
||||||
|
// The zero value is returned for coordinates outside of the image.
|
||||||
|
func (p *Image) OkLabAt(x, y int) Color {
|
||||||
|
if !image.Pt(x, y).In(p.Rect) {
|
||||||
|
return Color{}
|
||||||
|
}
|
||||||
|
|
||||||
|
i := p.PixOffset(x, y)
|
||||||
|
in := p.Pix[i : i+bytesPerPixel]
|
||||||
|
|
||||||
|
return Color{
|
||||||
|
Lightness: math.Float64frombits(binary.BigEndian.Uint64(in[0:8])),
|
||||||
|
ChromaA: math.Float64frombits(binary.BigEndian.Uint64(in[8:16])),
|
||||||
|
ChromaB: math.Float64frombits(binary.BigEndian.Uint64(in[16:24])),
|
||||||
|
A: math.Float64frombits(binary.BigEndian.Uint64(in[24:32])),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// PixOffset returns the offset into the [Pix] slice a pixel begins.
|
||||||
|
//
|
||||||
|
// The given coordinates must be inside the image.
|
||||||
|
func (p *Image) PixOffset(x, y int) int {
|
||||||
|
return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*bytesPerPixel
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set implements the [draw.Image] interface.
|
||||||
|
func (p *Image) Set(x, y int, c color.Color) {
|
||||||
|
if !image.Pt(x, y).In(p.Rect) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
p.setOkLab(x, y, FromColor(c))
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set implements the [draw.RGBA64Image] interface.
|
||||||
|
func (p *Image) SetRGBA64(x, y int, c color.RGBA64) {
|
||||||
|
if !image.Pt(x, y).In(p.Rect) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
p.setOkLab(x, y, FromRGBA(uint32(c.R), uint32(c.G), uint32(c.B), uint32(c.A)))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Image) setOkLab(x, y int, c Color) {
|
||||||
|
i := p.PixOffset(x, y)
|
||||||
|
out := p.Pix[i : i+bytesPerPixel]
|
||||||
|
|
||||||
|
binary.BigEndian.PutUint64(out[0:8], math.Float64bits(c.Lightness))
|
||||||
|
binary.BigEndian.PutUint64(out[8:16], math.Float64bits(c.ChromaA))
|
||||||
|
binary.BigEndian.PutUint64(out[16:24], math.Float64bits(c.ChromaB))
|
||||||
|
binary.BigEndian.PutUint64(out[24:32], math.Float64bits(c.A))
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetOkLab encodes the given color into the pixel at the given coordinates.
|
||||||
|
//
|
||||||
|
// Does nothing if the coordinates are outside the image.
|
||||||
|
func (p *Image) SetOkLab(x, y int, c Color) {
|
||||||
|
if !image.Pt(x, y).In(p.Rect) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
p.setOkLab(x, y, c)
|
||||||
|
}
|
||||||
|
|
||||||
|
// SubImage returns a new [Image] that shares the same underlying pixel data.
|
||||||
|
func (p *Image) SubImage(r image.Rectangle) *Image {
|
||||||
|
r = r.Intersect(p.Rect)
|
||||||
|
|
||||||
|
if r.Empty() {
|
||||||
|
return &Image{}
|
||||||
|
}
|
||||||
|
|
||||||
|
start := p.PixOffset(r.Min.X, r.Min.Y)
|
||||||
|
end := p.PixOffset(r.Max.X-1, r.Max.Y-1) + bytesPerPixel
|
||||||
|
|
||||||
|
return &Image{
|
||||||
|
Pix: p.Pix[start:end:end],
|
||||||
|
Stride: p.Stride,
|
||||||
|
Rect: r,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Opaque returns true if every pixel in the image would have an alpha value of 0xffff when
|
||||||
|
// converted to [color.RGBA64].
|
||||||
|
func (p *Image) Opaque() bool {
|
||||||
|
w, h := p.Rect.Dx(), p.Rect.Dy()
|
||||||
|
for y := 0; y < h; y++ {
|
||||||
|
row := p.Pix[y*p.Stride : y*p.Stride+w*bytesPerPixel]
|
||||||
|
for i, stop := 0, w*bytesPerPixel; i < stop; i += bytesPerPixel {
|
||||||
|
// we consider a pixel opaque if the NRGBA/RGBA methods
|
||||||
|
// would have returned 0xffff.
|
||||||
|
if uint32(math.Float64frombits(binary.BigEndian.Uint64(row[i+24:i+32]))*0xffff+0.5) != 0xffff {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewImage returns a new [Image] of the specified size.
|
||||||
|
func NewImage(r image.Rectangle) *Image {
|
||||||
|
return &Image{
|
||||||
|
Pix: make([]uint8, r.Dx()*r.Dy()*bytesPerPixel),
|
||||||
|
Stride: r.Dx() * bytesPerPixel,
|
||||||
|
Rect: r,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var (
|
||||||
|
// type assertions
|
||||||
|
_ interface {
|
||||||
|
image.Image
|
||||||
|
draw.Image
|
||||||
|
image.RGBA64Image
|
||||||
|
draw.RGBA64Image
|
||||||
|
} = (*Image)(nil)
|
||||||
|
)
|
||||||
245
image_test.go
Normal file
245
image_test.go
Normal file
@ -0,0 +1,245 @@
|
|||||||
|
package oklab
|
||||||
|
|
||||||
|
import (
|
||||||
|
"image"
|
||||||
|
"image/color"
|
||||||
|
"image/draw"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestNewImage(t *testing.T) {
|
||||||
|
r := image.Rect(13, 21, 34, 55)
|
||||||
|
img := NewImage(r)
|
||||||
|
|
||||||
|
if img.Rect != r {
|
||||||
|
t.Errorf("img.Rect = %v, want %v", img.Rect, r)
|
||||||
|
}
|
||||||
|
|
||||||
|
if got := img.Bounds(); got != r {
|
||||||
|
t.Errorf("img.Bounds() = %v, want %v", got, r)
|
||||||
|
}
|
||||||
|
|
||||||
|
if got := img.ColorModel(); got != Model {
|
||||||
|
t.Errorf("img.ColorModel() = %v, want %v", got, Model)
|
||||||
|
}
|
||||||
|
|
||||||
|
if got, want := img.Stride, r.Dx()*bytesPerPixel; got != want {
|
||||||
|
t.Errorf("img.Stride = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
|
||||||
|
if got, want := len(img.Pix), (r.Dy()-1)*img.Stride+r.Dx()*bytesPerPixel; got != want {
|
||||||
|
t.Errorf("len(img.Pix) = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func testColor(x, y int) Color {
|
||||||
|
return Color{
|
||||||
|
float64(x),
|
||||||
|
float64(y),
|
||||||
|
float64(x + y),
|
||||||
|
float64(x ^ y),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func mod(a int, m int) int {
|
||||||
|
a = a % m
|
||||||
|
if a < 0 {
|
||||||
|
// fucking intel.
|
||||||
|
a += m
|
||||||
|
}
|
||||||
|
return a
|
||||||
|
}
|
||||||
|
|
||||||
|
func testRGBA64Color(x, y int) color.RGBA64 {
|
||||||
|
a := mod(x^y, 0xffff)
|
||||||
|
|
||||||
|
return color.RGBA64{
|
||||||
|
uint16(mod(x, a+1)),
|
||||||
|
uint16(mod(y, a+1)),
|
||||||
|
uint16(mod(x+y, a+1)),
|
||||||
|
uint16(a),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestImage_Set(t *testing.T) {
|
||||||
|
r := image.Rect(13, 21, 34, 55)
|
||||||
|
img := NewImage(r)
|
||||||
|
|
||||||
|
// intentionally invoking SetOkLab beyond the boundaries of the image, here.
|
||||||
|
for y := r.Min.Y - 1; y <= r.Max.Y; y++ {
|
||||||
|
for x := r.Min.X - 1; x <= r.Max.X; x++ {
|
||||||
|
img.Set(x, y, testColor(x, y))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for y := r.Min.Y - 1; y <= r.Max.Y; y++ {
|
||||||
|
for x := r.Min.X - 1; x <= r.Max.X; x++ {
|
||||||
|
want := Color{}
|
||||||
|
|
||||||
|
if image.Pt(x, y).In(r) {
|
||||||
|
want = testColor(x, y)
|
||||||
|
}
|
||||||
|
|
||||||
|
got := img.At(x, y).(Color)
|
||||||
|
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("img.At(%d, %d) = %v, want %v", x, y, got, want)
|
||||||
|
// stop at the first error, please.
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestImage_SetRGBA64(t *testing.T) {
|
||||||
|
r := image.Rect(13, 21, 34, 55)
|
||||||
|
img := NewImage(r)
|
||||||
|
|
||||||
|
// intentionally invoking SetOkLab beyond the boundaries of the image, here.
|
||||||
|
for y := r.Min.Y - 1; y <= r.Max.Y; y++ {
|
||||||
|
for x := r.Min.X - 1; x <= r.Max.X; x++ {
|
||||||
|
img.SetRGBA64(x, y, testRGBA64Color(x, y))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for y := r.Min.Y - 1; y <= r.Max.Y; y++ {
|
||||||
|
for x := r.Min.X - 1; x <= r.Max.X; x++ {
|
||||||
|
want := color.RGBA64{}
|
||||||
|
|
||||||
|
if image.Pt(x, y).In(r) {
|
||||||
|
want = testRGBA64Color(x, y)
|
||||||
|
}
|
||||||
|
|
||||||
|
got := img.RGBA64At(x, y)
|
||||||
|
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("img.RGBA64At(%d, %d) = %v, want %v", x, y, got, want)
|
||||||
|
// stop at the first error, please.
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func setPixels(img *Image) {
|
||||||
|
for y := img.Rect.Min.Y - 1; y <= img.Rect.Max.Y; y++ {
|
||||||
|
for x := img.Rect.Min.X - 1; x <= img.Rect.Max.X; x++ {
|
||||||
|
img.SetOkLab(x, y, testColor(x, y))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func checkPixels(t *testing.T, img *Image) {
|
||||||
|
for y := img.Rect.Min.Y - 1; y <= img.Rect.Max.Y; y++ {
|
||||||
|
for x := img.Rect.Min.X - 1; x <= img.Rect.Max.X; x++ {
|
||||||
|
want := Color{}
|
||||||
|
|
||||||
|
if image.Pt(x, y).In(img.Rect) {
|
||||||
|
want = testColor(x, y)
|
||||||
|
}
|
||||||
|
|
||||||
|
got := img.OkLabAt(x, y)
|
||||||
|
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("checkPixels: img.OkLabAt(%d, %d) = %v, want %v", x, y, got, want)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestImage_SetOkLab(t *testing.T) {
|
||||||
|
r := image.Rect(13, 21, 34, 55)
|
||||||
|
img := NewImage(r)
|
||||||
|
|
||||||
|
setPixels(img)
|
||||||
|
checkPixels(t, img)
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestImage_SubImage(t *testing.T) {
|
||||||
|
r := image.Rect(13, 21, 34, 55)
|
||||||
|
img := NewImage(r)
|
||||||
|
|
||||||
|
setPixels(img)
|
||||||
|
|
||||||
|
for _, tt := range []struct {
|
||||||
|
name string
|
||||||
|
r image.Rectangle
|
||||||
|
}{
|
||||||
|
{"identity", r},
|
||||||
|
{"inset", r.Inset(1)},
|
||||||
|
{"outset", r.Inset(-1)},
|
||||||
|
{"left", r.Add(image.Pt(-1, 0))},
|
||||||
|
{"right", r.Add(image.Pt(1, 0))},
|
||||||
|
{"up", r.Add(image.Pt(0, -1))},
|
||||||
|
{"down", r.Add(image.Pt(0, 1))},
|
||||||
|
{"outside", image.Rect(-100, -100, 1, 1)},
|
||||||
|
} {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
subImage := img.SubImage(tt.r)
|
||||||
|
|
||||||
|
if got, want := subImage.Rect, img.Rect.Intersect(tt.r); got != want {
|
||||||
|
t.Errorf("subImage.Rect = %v, want %v", got, want)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if got, want := subImage.Stride, subImage.Rect.Dx()*bytesPerPixel; got < want {
|
||||||
|
t.Errorf("subImage.Stride = %v, want >= %v", got, want)
|
||||||
|
}
|
||||||
|
|
||||||
|
if got, want := len(subImage.Pix), (subImage.Rect.Dy()-1)*subImage.Stride+subImage.Rect.Dx()*bytesPerPixel; got != want {
|
||||||
|
t.Errorf("len(img.Pix) = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
|
||||||
|
checkPixels(t, subImage)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestImage_Opaque(t *testing.T) {
|
||||||
|
t.Run("empty", func(t *testing.T) {
|
||||||
|
// an empty image is opaque by virtue of not containing any pixels, opaque or otherwise.
|
||||||
|
got, want := NewImage(image.Rect(0, 0, 0, 0)).Opaque(), true
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("Opaque() = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("non-empty", func(t *testing.T) {
|
||||||
|
img := NewImage(image.Rect(13, 21, 34, 55))
|
||||||
|
|
||||||
|
// the pixels of a non-empty image will have an alpha value of zero,
|
||||||
|
// make it completely transparent.
|
||||||
|
got, want := img.Opaque(), false
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("img.Opaque() = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
|
||||||
|
t.Run("explicitly transparent", func(t *testing.T) {
|
||||||
|
// if we explicitly set every pixel to be transparent, the result should be the same.
|
||||||
|
draw.Draw(img, img.Rect, image.Transparent, image.Point{}, draw.Src)
|
||||||
|
got, want := img.Opaque(), false
|
||||||
|
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("img.Opaque() = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("opaque", func(t *testing.T) {
|
||||||
|
// make every pixel opaque.
|
||||||
|
draw.Draw(img, img.Rect, image.Opaque, image.Point{}, draw.Src)
|
||||||
|
got, want := img.Opaque(), true
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("img.Opaque() = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
|
||||||
|
t.Run("except for a single transparent pixel", func(t *testing.T) {
|
||||||
|
img.Set(14, 23, color.Transparent)
|
||||||
|
got, want := img.Opaque(), false
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("img.Opaque() = %v, want %v", got, want)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
})
|
||||||
|
})
|
||||||
|
}
|
||||||
Loading…
x
Reference in New Issue
Block a user