Image processing algorithms in pure Go

Last update: Jan 6, 2023

Comments: 15

bild

A collection of parallel image processing algorithms in pure Go.

The aim of this project is simplicity in use and development over absolute high performance, but most algorithms are designed to be efficient and make use of parallelism when available.

It uses packages from the standard library whenever possible to reduce dependency use and development abstractions.

All operations return image types from the standard library.

Documentation

The documentation for the various packages is available here.

CLI usage

Download and compile from sources:

go get github.com/anthonynsimon/bild

Or get the pre-compiled binaries for your platform on the releases page

bild

A collection of parallel image processing algorithms in pure Go

Usage:
  bild [command]

Available Commands:
  adjust      adjust basic image features like brightness or contrast
  blend       blend two images together
  blur        blur an image using the specified method
  channel     channel operations on images
  effect      apply effects on images
  help        Help about any command
  histogram   histogram operations on images
  imgio       i/o operations on images
  noise       noise generators
  segment     segment an image using the specified method

Flags:
  -h, --help      help for bild
      --version   version for bild

Use "bild [command] --help" for more information about a command.

For example, to apply a median effect with a radius of 1.5 on the image input.png, writing the result into a new file called output.png:

bild effect median --radius 1.5 input.png output.png

Install package

bild requires Go version 1.11 or greater.

go get github.com/anthonynsimon/bild/...

Basic package usage example:

package main

import (
    "github.com/anthonynsimon/bild/effect"
    "github.com/anthonynsimon/bild/imgio"
    "github.com/anthonynsimon/bild/transform"
)

func main() {
    img, err := imgio.Open("input.jpg")
    if err != nil {
        fmt.Println(err)
        return
    }

    inverted := effect.Invert(img)
    resized := transform.Resize(inverted, 800, 800, transform.Linear)
    rotated := transform.Rotate(resized, 45, nil)

    if err := imgio.Save("output.png", rotated, imgio.PNGEncoder()); err != nil {
        fmt.Println(err)
        return
    }
}

Output examples

Adjustment

import "github.com/anthonynsimon/bild/adjust"

Brightness

result := adjust.Brightness(img, 0.25)

Contrast

result := adjust.Contrast(img, -0.5)

Gamma

result := adjust.Gamma(img, 2.2)

Hue

result := adjust.Hue(img, -42)

Saturation

result := adjust.Saturation(img, 0.5)

Blend modes

import "github.com/anthonynsimon/bild/blend"

result := blend.Multiply(bg, fg)

Add	Color Burn	Color Dodge

Darken	Difference	Divide

Exclusion	Lighten	Linear Burn

Linear Light	Multiply	Normal

Opacity	Overlay	Screen

Soft Light	Subtract

Blur

import "github.com/anthonynsimon/bild/blur"

Box Blur

result := blur.Box(img, 3.0)

Gaussian Blur

result := blur.Gaussian(img, 3.0)

Channel

import "github.com/anthonynsimon/bild/channel"

Extract Channels

result := channel.Extract(img, channel.Alpha)

Extract Multiple Channels

result := channel.ExtractMultiple(img, channel.Red, channel.Alpha)

Effect

import "github.com/anthonynsimon/bild/effect"

Dilate

result := effect.Dilate(img, 3)

Edge Detection

result := effect.EdgeDetection(img, 1.0)

Emboss

result := effect.Emboss(img)

Erode

result := effect.Erode(img, 3)

Grayscale

result := effect.Grayscale(img)

Invert

result := effect.Invert(img)

Median

result := effect.Median(img, 10.0)

Sepia

result := effect.Sepia(img)

Sharpen

result := effect.Sharpen(img)

Sobel

result := effect.Sobel(img)

Unsharp Mask

result := effect.UnsharpMask(img, 0.6, 1.2)

Histogram

import "github.com/anthonynsimon/bild/histogram"

RGBA Histogram

hist := histogram.NewRGBAHistogram(img)
result := hist.Image()

Noise

import "github.com/anthonynsimon/bild/noise"

Uniform colored

result := noise.Generate(280, 280, &noise.Options{Monochrome: false, NoiseFn: noise.Uniform})

Binary monochrome

result := noise.Generate(280, 280, &noise.Options{Monochrome: true, NoiseFn: noise.Binary})

Gaussian monochrome

result := noise.Generate(280, 280, &noise.Options{Monochrome: true, NoiseFn: noise.Gaussian})

Perlin Noise

result := noise.GeneratePerlin(280, 280, 0.25)

Paint

import "github.com/anthonynsimon/bild/paint"

Flood Fill

// Fuzz is the percentage of maximum color distance that is tolerated
result := paint.FloodFill(img, image.Point{240, 0}, color.RGBA{255, 0, 0, 255}, 15)

Segmentation

import "github.com/anthonynsimon/bild/segment"

Threshold

result := segment.Threshold(img, 128)

Transform

import "github.com/anthonynsimon/bild/transform"

Crop

// Source image is 280x280
result := transform.Crop(img, image.Rect(70,70,210,210))

FlipH

result := transform.FlipH(img)

FlipV

result := transform.FlipV(img)

Resize Resampling Filters

result := transform.Resize(img, 280, 280, transform.Linear)

Nearest Neighbor	Linear	Gaussian

Mitchell Netravali	Catmull Rom	Lanczos

Rotate

// Options set to nil will use defaults (ResizeBounds set to false, Pivot at center)
result := transform.Rotate(img, -45.0, nil)

// If ResizeBounds is set to true, the full rotation bounding area is used
result := transform.Rotate(img, -45.0, &transform.RotationOptions{ResizeBounds: true})

// Pivot coordinates are set from the top-left corner
// Notice ResizeBounds being set to default (false)
result := transform.Rotate(img, -45.0, &transform.RotationOptions{Pivot: &image.Point{0, 0}})

Shear Horizontal

result := transform.ShearH(img, 30)

Shear Vertical

result := transform.ShearV(img, 30)

Translate

result := transform.Translate(img, 80, 0)

Contribute

Want to hack on the project? Any kind of contribution is welcome!
Simply follow the next steps:

Fork the project.
Create a new branch.
Make your changes and write tests when practical.
Commit your changes to the new branch.
Send a pull request, it will be reviewed shortly.

In case you want to add a feature, please create a new issue and briefly explain what the feature would consist of. For bugs or requests, before creating an issue please check if one has already been created for it.

Changelog

Please see the changelog for more details.

License

This project is licensed under the MIT license. Please read the LICENSE file.

Owner

Anthony N. Simon

Costa Rican expat in Germany. Avid traveler. Voracious reader.

https://github.com/anthonynsimon/bild

Comments

Switch fuzz to diff tolerance between colours

@defart would it make sense to switch from fuzz (distance based) to color difference tolerance?

This way setting the tolerance would allow the algorithm to fill pixels by similarity instead of by distance from point. So for example if tolerance is set to 12 (uint8 range 0...255), then all colours that are within a diff of +-12 will be matched.

After some quick research it seems like most photo editing software, including Photoshop, use a version of this setting.

I created a branch with the proposal, check it out here

Photoshop result:

bild paint.FloodFill result (after switching to proposed method):
Introduce new method for shallow copying image

Hi. I noticed there are many allocations in this library during operations. We use it in our web service to resize images on the fly so i optimized it a little. This is unfinished pull request without tests just to check the idea of optimization.
[Feature]Perlin noise
I have added few files in my local repo , that enables noise package to give images with coherent noise .Yes , using parallel implementation , like as of other noise functions . I wanted to know about

should i commit directly to master branch .

is it necessary to write tests for noise functions

Make gaussian blur using separable convolution

Hi,

I just noticed that Gaussian blur is not implemented using separable convolutions so I implemented it. The speed up is orders of magnitude for large kernels and large images.

Basically on my machine I get a speedup of 20x for a blur radius 30 pixels and a relatively large image as shown below:

$ time bild_0.11 blur gaussian --radius 30 ~/Downloads/cat.jpg ~/Downloads/out.jpg

real	0m29.641s
user	1m28.880s
sys	0m0.320s

$ time bild-fast-gaussian blur gaussian --radius 30 ~/Downloads/cat.jpg ~/Downloads/out.jpg

real	0m1.430s
user	0m5.316s
sys	0m0.036s

$ file ~/Downloads/cat.jpg
/path/to/my/home/Downloads/cat.jpg: JPEG image data, Exif standard: [TIFF image data, little-endian, direntries=1, copyright=Image protected by copyright. Contact  National Geographic Creative at: Telephone:202.857.7537,], baseline, precision 8, 2048x1365, frames 3

Cheers, Angelos

Add the ability to pass heuristics value in effect.Grayscale

The current implementation uses 0.3R + 0.6G + 0.1B as the heuristic which produces choppy results on certain images. I've found that 0.299R + 0.587G + 0.114B produces much better results. There should be a way to set this heuristic.
Rotate() results in panic on some images

I've encountered some images for which the Rotate() function results in: runtime error: slice bounds out of range

The error seems to be happening on rotate.go:111: copy(dst.Pix[dstPos:dstPos+4], src.Pix[srcPos:srcPos+4])

An image that can reproduce the error: https://static.thumbtackstatic.com/pictures/61/41zcu25h98b0rquu.jpg

FWIW, opening that image in an editor (e.g. Preview on mac) and simply re-saving it seems to resolve the issue. Unsure what to make of that.

Please let me know if I can provide any more info!
imgio.PNGEncoder() not working

After using go get github.com/anthonynsimon/bild (go mod file shows it getting v0.10.0) and pasting the readme example, VSCode shows that imgio.PNGEncoder() doesn't exist. After looking into the /pkg/mod/github.com/anthonynsimon/[email protected]/imgio/io.go file, I only have the Open, Encode, Save functions. I'm running go 1.13, currently on a Windows 10 host.

I had to change the line: imgio.Save("output.png", rotated, imgio.PNGEncoder()) to imgio.Save("output.png", rotated, imgio.PNG)

Not sure if there's a problem with the copy served to me, or the README file is out of date, but would love some clarification if possible. Thanks!

Rotation of large images seems super slow.

I was just trying a basic example:

package main

import (
    "github.com/anthonynsimon/bild/imgio"
    "github.com/anthonynsimon/bild/transform"
)

func main() {
    img, err := imgio.Open("PW2_8123.JPG")
    if err != nil {
        panic(err)
    }

    rotated := transform.Rotate(img, 90, nil)

    if err := imgio.Save("filename", rotated, imgio.PNG); err != nil {
        panic(err)
    }
}

And it took super long:

$ time ./main

real    0m26.787s
user    0m41.122s
sys 0m0.958s

The image is a 10mb photo.

[bug] runtime panic when rotating some images

Hi there,

this issue might be related to #60 (coming back to this later). I'm running go1.13.7 linux/amd64 using go modules and wrote some example code (pyrox777/transform-example) to ease reproducibility. When rotating an image, represented in RGBA, with dimensions of 5535x3690 pixels (source) by 270° clockwise with ResizeBounds set to true, the panic is triggered. Here is the output:

~/.../pyrox777/transform-example >>> go run main.go ~/Downloads/erwan-hesry-IqB5MPcQp6k-unsplash.jpg /tmp/out.png
reading from /home/xxx/Downloads/erwan-hesry-IqB5MPcQp6k-unsplash.jpg
rotating image by 270.000000° clockwise
panic: runtime error: slice bounds out of range [:81696604] with capacity 81696600

goroutine 23 [running]:
github.com/anthonynsimon/bild/transform.Rotate.func1(0xd37, 0xe6a)
        /home/xxx/go/pkg/mod/github.com/anthonynsimon/[email protected]/transform/rotate.go:111 +0x37d
github.com/anthonynsimon/bild/parallel.Line.func1(0xc000018110, 0xc000020240, 0xd37, 0xe6a)
        /home/xxx/go/pkg/mod/github.com/anthonynsimon/[email protected]/parallel/parallel.go:33 +0x6a
created by github.com/anthonynsimon/bild/parallel.Line
        /home/xxx/go/pkg/mod/github.com/anthonynsimon/[email protected]/parallel/parallel.go:31 +0x104
exit status 2

This is not the case when ResizeBounds is false, but I could not point out yet if this branch is the culprit.

Additionally, as started above, I was able to reproduce the panic with the image linked in #60:

~/.../pyrox777/transform-example >>> go run main.go ~/Downloads/41zcu25h98b0rquu.jpg /tmp/out.png
reading from /home/xxx/Downloads/41zcu25h98b0rquu.jpg
rotating image by 270.000000° clockwise
panic: runtime error: slice bounds out of range [:1223044] with capacity 1223040

goroutine 8 [running]:
github.com/anthonynsimon/bild/transform.Rotate.func1(0x1b8, 0x1e0)
        /home/xxx/go/pkg/mod/github.com/anthonynsimon/[email protected]/transform/rotate.go:111 +0x37d
github.com/anthonynsimon/bild/parallel.Line.func1(0xc000018120, 0xc000020360, 0x1b8, 0x1e0)
        /home/xxx/go/pkg/mod/github.com/anthonynsimon/[email protected]/parallel/parallel.go:33 +0x6a
created by github.com/anthonynsimon/bild/parallel.Line
        /home/xxx/go/pkg/mod/github.com/anthonynsimon/[email protected]/parallel/parallel.go:31 +0x104
exit status 2

So, thanks for this project and also having a look at this! :)

Edit: I have changed the title because the second image is not considered huge by me. But it has uneven dimensions as well (637x480). So maybe this could be a hint?

feat: improve adjust apply

Benchmark Result

$ go test -run=apply_test.go -benchtime=1s -bench=^BenchmarkApply -cpuprofile=cpu.out -benchmem -memprofile=mem.out -trace trace.out -count=5 > old.txt
$ go test -run=apply_test.go -benchtime=1s -bench=^BenchmarkApply -cpuprofile=cpu.out -benchmem -memprofile=mem.out -trace trace.out -count=5 > new.txt

benchcmp old.txt new.txt Result:

benchmark                 old ns/op     new ns/op     delta
BenchmarkApply-8          216           208           -3.70%
BenchmarkApply-8          216           208           -3.70%
BenchmarkApply-8          216           207           -4.17%
BenchmarkApply-8          215           209           -2.79%
BenchmarkApply-8          216           210           -2.78%

benchmark                 old allocs     new allocs     delta
BenchmarkApply-8          3              3              +0.00%
BenchmarkApply-8          3              3              +0.00%
BenchmarkApply-8          3              3              +0.00%
BenchmarkApply-8          3              3              +0.00%
BenchmarkApply-8          3              3              +0.00%

benchmark                 old bytes     new bytes     delta
BenchmarkApply-8          112           112           +0.00%
BenchmarkApply-8          112           112           +0.00%
BenchmarkApply-8          112           112           +0.00%
BenchmarkApply-8          112           112           +0.00%
BenchmarkApply-8          112           112           +0.00%

Fix rotate panic

Hi,

I have the same problem as in this issue https://github.com/anthonynsimon/bild/issues/78. I found a solution to this.

We must not set RGBA colours by pix slice. We must use .Set()

Explained here: https://groups.google.com/forum/#!topic/golang-nuts/WXr89MY9MBw

And some explanaitions about slice[a:b:c] construct https://stackoverflow.com/questions/27938177/golang-slice-slicing-a-slice-with-sliceabc
General Inquiry
Hello, I'm looking for a library that would help me build an image manipulation service in Go. A common use case of the service is :

create a blank image canvas

overlay a static background image over the canvas

add text over the canvas

stream the final canvas as an image and return it to clients

Does your library help accomplish this use case?

transform.Crop performance goes bad when rect size is small

my result is below.

goos: linux
goarch: amd64
pkg: test
cpu: AMD Ryzen 7 3700X 8-Core Processor
BenchmarkMyCrop-16                 14307             79645 ns/op
BenchmarkResizeCrop-16               134           8771603 ns/op

my test code is below.

const size = 50

func BenchmarkMyCrop(b *testing.B) {
	f, err := ioutil.ReadFile("img.png")
	if err != nil {
		panic(err)
	}
	dImage, _, err := image.Decode(bytes.NewReader(f))
	if err != nil {
		panic(err)
	}
	rect := image.Rect(0, 0, size, size)

	SubImage := func (img image.Image, r image.Rectangle) image.Image {
		var bgSize = image.Rect(0, 0, r.Dx(), r.Dy())
		var bg = image.NewNRGBA(bgSize)
		draw.Draw(bg, bg.Bounds(), img, r.Min, draw.Src)
		return bg
	}
	for i := 0; i < b.N; i++ {
		SubImage(dImage, rect)
	}
}

func BenchmarkResizeCrop(b *testing.B) {
	f, err := ioutil.ReadFile("img.png")
	if err != nil {
		panic(err)
	}
	dImage, _, err := image.Decode(bytes.NewReader(f))
	if err != nil {
		panic(err)
	}
	rect := image.Rect(0, 0, size, size)
	for i := 0; i < b.N; i++ {
		transform.Crop(dImage, rect)
	}
}

my test image is below.

Feature Request: Lens effect support

hi,

Thanks for this project. I'd like to request a feature to do lens distortions on parts of the image similar to http://www.imagemagick.org/Usage/distorts/#barrel

thanks

Test failures on AArch64

Hi,

I've observed a few failures in the test suite when running on AArch64:

...
=== RUN   TestRotate
--- FAIL: TestRotate (0.00s)
    rotate_test.go:175: Rotate angle 45.0 at center, don't preserve bounds:
        expected:
        Bounds: (0,0)-(5,5)
        Stride: 20
        0X5C, 0X5C, 0X5C, 0X87, 0X85, 0X85, 0X85, 0XF7, 0X81, 0X81, 0X81, 0XFF, 0X8C, 0X8C, 0X8C, 0XD1, 0X33, 0X33, 0X33, 0X33, 
        0XF0, 0XF0, 0XF0, 0XF7, 0XD3, 0XD3, 0XD3, 0XFF, 0XAD, 0XAD, 0XAD, 0XFF, 0XEF, 0XEF, 0XEF, 0XFD, 0X95, 0X95, 0X95, 0X95, 
        0XDF, 0XDE, 0XDE, 0XDE, 0XFD, 0XDA, 0XDA, 0XDB, 0XFC, 0XB3, 0XB3, 0XB7, 0XF6, 0XEC, 0XEC, 0XEC, 0X7E, 0X7E, 0X7E, 0X7E, 
        0X35, 0X2B, 0X2B, 0X2B, 0XC9, 0X6F, 0X6F, 0X6F, 0XF5, 0X7C, 0X7C, 0X7C, 0X82, 0X54, 0X54, 0X54, 0XA, 0XA, 0XA, 0XA, 
        0X0, 0X0, 0X0, 0X0, 0X35, 0X1B, 0X1B, 0X1B, 0X79, 0X3D, 0X3D, 0X3D, 0XA, 0X5, 0X5, 0X5, 0X0, 0X0, 0X0, 0X0, 
        
        actual:
        Bounds: (0,0)-(5,5)
        Stride: 20
        0X57, 0X57, 0X57, 0X87, 0X7E, 0X7E, 0X7E, 0XF7, 0X81, 0X81, 0X81, 0XFF, 0X8C, 0X8C, 0X8C, 0XD1, 0X33, 0X33, 0X33, 0X33, 
        0XE9, 0XE9, 0XE9, 0XF7, 0XC8, 0XC8, 0XC8, 0XFF, 0XAD, 0XAD, 0XAD, 0XFF, 0XEF, 0XEF, 0XEF, 0XFD, 0X95, 0X95, 0X95, 0X95, 
        0XDF, 0XDE, 0XDE, 0XDE, 0XFD, 0XDA, 0XDA, 0XDB, 0XFC, 0XB3, 0XB3, 0XB7, 0XF6, 0XEC, 0XEC, 0XEC, 0X7E, 0X7E, 0X7E, 0X7E, 
        0X35, 0X2B, 0X2B, 0X2B, 0XC9, 0X6F, 0X6F, 0X6F, 0XF5, 0X7C, 0X7C, 0X7C, 0X82, 0X54, 0X54, 0X54, 0XA, 0XA, 0XA, 0XA, 
        0X0, 0X0, 0X0, 0X0, 0X35, 0X1B, 0X1B, 0X1B, 0X79, 0X3D, 0X3D, 0X3D, 0XA, 0X5, 0X5, 0X5, 0X0, 0X0, 0X0, 0X0, 
=== RUN   TestFlipH
--- PASS: TestFlipH (0.00s)
=== RUN   TestFlipV
--- PASS: TestFlipV (0.00s)
=== RUN   TestShearH
--- FAIL: TestShearH (0.01s)
    shear_test.go:146: ShearH:
        expected: 
        Bounds: (0,0)-(16,8)
        Stride: 64
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X5, 0X5, 0X5, 0X5, 0X64, 0X64, 0X64, 0X64, 0XF1, 0XF1, 0XF1, 0XF1, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFA, 0XFA, 0XFA, 0XFA, 0XB1, 0XB1, 0XB1, 0XB1, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X20, 0X20, 0X20, 0X20, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X5, 0X5, 0X5, 0X5, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X4E, 0X4E, 0X4E, 0X4E, 0XDF, 0XDF, 0XDF, 0XDF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XBB, 0XBB, 0XBB, 0XBB, 0X20, 0X20, 0X20, 0X20, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        
        actual: 
        Bounds: (0,0)-(15,8)
        Stride: 60
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X8, 0X8, 0X8, 0X8, 0X8A, 0X8A, 0X8A, 0X8A, 0XFD, 0XFD, 0XFD, 0XFD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XE2, 0XE2, 0XE2, 0XE2, 0X52, 0X52, 0X52, 0X52, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X7, 0X7, 0X7, 0X7, 0X74, 0X74, 0X74, 0X74, 0XF3, 0XF3, 0XF3, 0XF3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XE9, 0XE9, 0XE9, 0XE9, 0X60, 0X60, 0X60, 0X60, 0X5, 0X5, 0X5, 0X5, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X6, 0X6, 0X6, 0X6, 0X6F, 0X6F, 0X6F, 0X6F, 0XF0, 0XF0, 0XF0, 0XF0, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XEB, 0XEB, 0XEB, 0XEB, 0X65, 0X65, 0X65, 0X65, 0X5, 0X5, 0X5, 0X5, 0X0, 0X0, 0X0, 0X0, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X60, 0X60, 0X60, 0X60, 0XEE, 0XEE, 0XEE, 0XEE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF7, 0XF7, 0XF7, 0XF7, 0X70, 0X70, 0X70, 0X70, 0X6, 0X6, 0X6, 0X6, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X6, 0X6, 0X6, 0X6, 0XA5, 0XA5, 0XA5, 0XA5, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XE6, 0XE6, 0XE6, 0XE6, 0X2A, 0X2A, 0X2A, 0X2A, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X0, 0X0, 0X0, 0X0, 0X5, 0X5, 0X5, 0X5, 0X65, 0X65, 0X65, 0X65, 0XEB, 0XEB, 0XEB, 0XEB, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF0, 0XF0, 0XF0, 0XF0, 0X6F, 0X6F, 0X6F, 0X6F, 0X6, 0X6, 0X6, 0X6, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X5, 0X5, 0X5, 0X5, 0X60, 0X60, 0X60, 0X60, 0XE9, 0XE9, 0XE9, 0XE9, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF3, 0XF3, 0XF3, 0XF3, 0X74, 0X74, 0X74, 0X74, 0X7, 0X7, 0X7, 0X7, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X52, 0X52, 0X52, 0X52, 0XE2, 0XE2, 0XE2, 0XE2, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFD, 0XFD, 0XFD, 0XFD, 0X8A, 0X8A, 0X8A, 0X8A, 0X8, 0X8, 0X8, 0X8, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
=== RUN   TestShearV
--- FAIL: TestShearV (0.03s)
    shear_test.go:298: ShearH:
        expected: 
        Bounds: (0,0)-(8,16)
        Stride: 32
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X5, 0X5, 0X5, 0X5, 0X4E, 0X4E, 0X4E, 0X4E, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XDF, 0XDF, 0XDF, 0XDF, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X0, 0X0, 0X0, 0X0, 0X4, 0X4, 0X4, 0X4, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X5, 0X5, 0X5, 0X5, 0X58, 0X58, 0X58, 0X58, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X64, 0X64, 0X64, 0X64, 0XE3, 0XE3, 0XE3, 0XE3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0XF1, 0XF1, 0XF1, 0XF1, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XBB, 0XBB, 0XBB, 0XBB, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X20, 0X20, 0X20, 0X20, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0XFB, 0XFB, 0XFB, 0XFB, 0XA8, 0XA8, 0XA8, 0XA8, 0X1C, 0X1C, 0X1C, 0X1C, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0XB1, 0XB1, 0XB1, 0XB1, 0X20, 0X20, 0X20, 0X20, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        
        actual: 
        Bounds: (0,0)-(8,15)
        Stride: 32
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X5, 0X5, 0X5, 0X5, 0X52, 0X52, 0X52, 0X52, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X5, 0X5, 0X5, 0X5, 0X60, 0X60, 0X60, 0X60, 0XE3, 0XE3, 0XE3, 0XE3, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X6, 0X6, 0X6, 0X6, 0X65, 0X65, 0X65, 0X65, 0XE9, 0XE9, 0XE9, 0XE9, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X6, 0X6, 0X6, 0X6, 0X60, 0X60, 0X60, 0X60, 0XA5, 0XA5, 0XA5, 0XA5, 0XEB, 0XEB, 0XEB, 0XEB, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X0, 0X0, 0X0, 0X0, 0X7, 0X7, 0X7, 0X7, 0X6F, 0X6F, 0X6F, 0X6F, 0XEE, 0XEE, 0XEE, 0XEE, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X8, 0X8, 0X8, 0X8, 0X74, 0X74, 0X74, 0X74, 0XF0, 0XF0, 0XF0, 0XF0, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0X8A, 0X8A, 0X8A, 0X8A, 0XF3, 0XF3, 0XF3, 0XF3, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 
        0XFD, 0XFD, 0XFD, 0XFD, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFD, 0XFD, 0XFD, 0XFD, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF3, 0XF3, 0XF3, 0XF3, 0X8A, 0X8A, 0X8A, 0X8A, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF0, 0XF0, 0XF0, 0XF0, 0X74, 0X74, 0X74, 0X74, 0X8, 0X8, 0X8, 0X8, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XF7, 0XF7, 0XF7, 0XF7, 0XE6, 0XE6, 0XE6, 0XE6, 0X6F, 0X6F, 0X6F, 0X6F, 0X6, 0X6, 0X6, 0X6, 0X0, 0X0, 0X0, 0X0, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XEB, 0XEB, 0XEB, 0XEB, 0X70, 0X70, 0X70, 0X70, 0X2A, 0X2A, 0X2A, 0X2A, 0X6, 0X6, 0X6, 0X6, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0XFF, 0XFF, 0XFF, 0XFF, 0XE9, 0XE9, 0XE9, 0XE9, 0X65, 0X65, 0X65, 0X65, 0X5, 0X5, 0X5, 0X5, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0XE3, 0XE3, 0XE3, 0XE3, 0X60, 0X60, 0X60, 0X60, 0X5, 0X5, 0X5, 0X5, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
        0X52, 0X52, 0X52, 0X52, 0X5, 0X5, 0X5, 0X5, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 0X0, 
=== RUN   TestTranslate
--- PASS: TestTranslate (0.00s)
FAIL
FAIL	github.com/anthonynsimon/bild/transform	0.085s
=== RUN   TestRGBToHSV
--- PASS: TestRGBToHSV (0.00s)
...

I wonder if this is related to this issue:
https://github.com/fogleman/gg/issues/79