bimg

Go small but featured library for blazing fast image processing based on libvips using C bindings.

bimg is designed to be a small and efficient library with a specific but useful and generic set of features. It uses internally libvips, which is typically 4x faster than using the quickest ImageMagick and GraphicsMagick settings or Go native image package, and in some cases it's even 8x faster processing JPEG images. bimg can read JPEG, PNG, WEBP, TIFF and Magick formats and it can output to JPEG, PNG and WEBP.

It support common image transformation operations such as crop, resize, rotate... and image conversion into multiple formats.

To getting started see the examples and programmatic API documentation.

bimg was heavily inspired in sharp, a great node.js package for image processing build by Lovell Fuller.

Note: bimg is still a beta package. PR and issues are highly appreciated

Prerequisites

• libvips v7.40.0+ (7.42.0+ recommended)
• C compatible compiler such as gcc 4.6+ or clang 3.0+
• Go 1.3+

Installation

go get gopkg.in/h2non/bimg.v0

libvips

Run the following script as sudo (supports OSX, Debian/Ubuntu, Redhat, Fedora, Amazon Linux):

curl -s https://raw.githubusercontent.com/lovell/sharp/master/preinstall.sh | sudo bash -

The install script requires curl and pkg-config

Supported image operations

• Resize
• Enlarge
• Crop
• Rotate
• Flip
• Extract area
• EXIF metadata (size, alpha channel, profile, orientation...)
• Format conversion

Performance

libvips is probably the faster open source solution for image processing. Here you can see some performance test comparisons for multiple scenarios:

• libvips speed and memory usage
• sharp performance tests

bimg performance tests coming soon!

API

Examples

import (
  "fmt"
  "os"
  "gopkg.in/h2non/bimg.v0"
)

Resize

buffer, err := bimg.Read("image.jpg")
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

newImage, err := bimg.NewImage(buffer).Resize(800, 600)
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

size, err := bimg.NewImage(newImage).Size()
if size.Width == 400 && size.Height == 300 {
  fmt.Println("The image size is valid")
}

bimg.Write("new.jpg", newImage)

Rotate

buffer, err := bimg.Read("image.jpg")
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

newImage, err := bimg.NewImage(buffer).Rotate(90)
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

bimg.Write("new.jpg", newImage)

Convert

buffer, err := bimg.Read("image.jpg")
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

newImage, err := bimg.NewImage(buffer).Convert(bimg.PNG)
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

if bimg.NewImage(newImage).Type() == "png" {
  fmt.Fprintln(os.Stderr, "The image was converted into png")
}

Process

options := bimg.Options{
  Width:        800,
  Height:       600,
  Crop:         true,
  Quality:      95,
  Rotate:       180,
}

buffer, err := bimg.Read("image.jpg")
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

newImage, err := bimg.NewImage(buffer).Process(options)
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

bimg.Write("new.jpg", newImage)

func DetermineImageTypeName

func DetermineImageTypeName(buf []byte) string

func Initialize

func Initialize()

func IsTypeNameSupported

func IsTypeNameSupported(t string) bool

func IsTypeSupported

func IsTypeSupported(t ImageType) bool

func Read

func Read(path string) ([]byte, error)

func Resize

func Resize(buf []byte, o Options) ([]byte, error)

func Shutdown

func Shutdown()

type Angle

type Angle int

const (
  D0   Angle = C.VIPS_ANGLE_D0
  D90  Angle = C.VIPS_ANGLE_D90
  D180 Angle = C.VIPS_ANGLE_D180
  D270 Angle = C.VIPS_ANGLE_D270
)

type Direction

type Direction int

const (
  HORIZONTAL Direction = C.VIPS_DIRECTION_HORIZONTAL
  VERTICAL   Direction = C.VIPS_DIRECTION_VERTICAL
)

type Gravity

type Gravity int

const (
  CENTRE Gravity = iota
  NORTH
  EAST
  SOUTH
  WEST
)

type Image

type Image struct {
}

func NewImage

func NewImage(buf []byte) *Image

func (*Image) Convert

func (i *Image) Convert(t ImageType) ([]byte, error)

func (*Image) Crop

func (i *Image) Crop(width int, height int) ([]byte, error)

func (*Image) Extract

func (i *Image) Extract(top int, left int, width int, height int) ([]byte, error)

func (*Image) Flip

func (i *Image) Flip() ([]byte, error)

func (*Image) Flop

func (i *Image) Flop() ([]byte, error)

func (*Image) Metadata

func (i *Image) Metadata() (ImageMetadata, error)

func (*Image) Process

func (i *Image) Process(o Options) ([]byte, error)

func (*Image) Resize

func (i *Image) Resize(width int, height int) ([]byte, error)

func (*Image) Rotate

func (i *Image) Rotate(a Angle) ([]byte, error)

func (*Image) Size

func (i *Image) Size() (ImageSize, error)

func (*Image) Type

func (i *Image) Type() string

type ImageMetadata

type ImageMetadata struct {
  Orientation int
  Alpha       bool
  Profile     bool
  Space       int
  Type        string
  Size        ImageSize
}

func Metadata

func Metadata(buf []byte) (ImageMetadata, error)

type ImageSize

type ImageSize struct {
  Width  int
  Height int
}

func Size

func Size(buf []byte) (ImageSize, error)

type ImageType

type ImageType int

const (
  UNKNOWN ImageType = iota
  JPEG
  WEBP
  PNG
  TIFF
  MAGICK
)

func DetermineImageType

func DetermineImageType(buf []byte) ImageType

type Interpolator

type Interpolator int

const (
  BICUBIC Interpolator = iota
  BILINEAR
  NOHALO
)

func (Interpolator) String

func (i Interpolator) String() string

type Options

type Options struct {
  Height       int
  Width        int
  Top          int
  Left         int
  Crop         bool
  Enlarge      bool
  Extend       int
  Embed        bool
  Quality      int
  Compression  int
  Type         ImageType
  Rotate       Angle
  Flip         Direction
  Gravity      Gravity
  Interpolator Interpolator
}

License

MIT - Tomas Aparicio