bild

A collection of parallel image processing algorithms in pure Go.

The aim of this project is simplicity in use and development over high performance, but most algorithms are designed to be efficient and make use of parallelism when available. It is based on standard Go packages to reduce dependency use and development abstractions.

Notice: This package is under heavy development and the API might change at any time until a 1.0 version is reached.

Install

bild requires Go version 1.4 or greater.

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

Notice the '...' at the end, this is to signify that you want all the packages on the repo. In your code, simply import the specific package that you want to use (see example below).

Basic 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("filename.jpg")
    if err != nil {
        panic(err)
    }

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

    // Or imgio.JPEGEncoder(95) as encoder for JPG with quality of 95%
    if err := imgio.Save("filename.png", rotated, imgio.PNGEncoder()); err != nil {
        panic(err)
    }
}

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 Channel

result := channel.Extract(img, 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})

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)

GitHub