bimg

package module
v2.0.0-...-fe4bf5c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 23, 2025 License: MIT Imports: 13 Imported by: 0

README

bimg GoDoc Coverage Status License

Small Go package for fast high-level image processing using libvips via C bindings, providing a simple programmatic API.

bimg was designed to be a small and efficient library supporting common image operations such as crop, resize, rotate, zoom or watermark. It can read JPEG, PNG, WEBP natively, and optionally TIFF, PDF, GIF and SVG formats if libvips@8.3+ is compiled with proper library bindings. Lastly AVIF is supported as of libvips@8.9+. For AVIF support libheif needs to be compiled with an applicable AVIF en-/decoder.

bimg is able to output images as JPEG, PNG and WEBP formats, including transparent conversion across them.

bimg uses internally libvips, a powerful library written in C for image processing which requires a low memory footprint and it's 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.

If you're looking for an HTTP based image processing solution, see imaginary.

bimg was heavily inspired in sharp, its homologous package built for node.js. bimg is used in production environments processing thousands of images per day.

v1 notice: bimg introduces some minor breaking changes in v1 release. If you're using gopkg.in, you can still rely in the v0 without worrying about API breaking changes.

Contents

Supported image operations

  • Resize
  • Enlarge
  • Crop (including smart crop support, libvips 8.5+)
  • Rotate (with auto-rotate based on EXIF orientation)
  • Flip (with auto-flip based on EXIF metadata)
  • Flop
  • Zoom
  • Thumbnail
  • Extract area
  • Watermark (using text or image)
  • Gaussian blur effect
  • Custom output color space (RGB, grayscale...)
  • Format conversion (with additional quality/compression settings)
  • EXIF metadata (size, alpha channel, profile, orientation...)
  • Trim (libvips 8.6+)

Prerequisites

  • libvips 8.3+ (8.10+ recommended)
  • C compatible compiler such as gcc 4.6+ or clang 3.0+
  • Go 1.17+

Note:

  • libvips v8.3+ is required for GIF, PDF and SVG support.
  • libvips v8.9+ is required for AVIF support. libheif compiled with a AVIF en-/decoder also needs to be present.
  • libvips v8.11+ is required for JPEG2000 support.

Installation

go get -u github.com/h2non/bimg/v2
libvips

Follow libvips installation instructions:

https://libvips.github.io/libvips/install.html

Performance

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

Benchmark

Tested using Go 1.5.1 and libvips-7.42.3 in OSX i7 2.7Ghz

BenchmarkRotateJpeg-8     	      20	  64686945 ns/op
BenchmarkResizeLargeJpeg-8	      20	  63390416 ns/op
BenchmarkResizePng-8      	     100	  18147294 ns/op
BenchmarkResizeWebP-8     	     100	  20836741 ns/op
BenchmarkConvertToJpeg-8  	     100	  12831812 ns/op
BenchmarkConvertToPng-8   	      10	 128901422 ns/op
BenchmarkConvertToWebp-8  	      10	 204027990 ns/op
BenchmarkCropJpeg-8       	      30	  59068572 ns/op
BenchmarkCropPng-8        	      10	 117303259 ns/op
BenchmarkCropWebP-8       	      10	 107060659 ns/op
BenchmarkExtractJpeg-8    	      50	  30708919 ns/op
BenchmarkExtractPng-8     	    3000	    595546 ns/op
BenchmarkExtractWebp-8    	    3000	    386379 ns/op
BenchmarkZoomJpeg-8       	      10	 160005424 ns/op
BenchmarkZoomPng-8        	      30	  44561047 ns/op
BenchmarkZoomWebp-8       	      10	 126732678 ns/op
BenchmarkWatermarkJpeg-8  	      20	  79006133 ns/op
BenchmarkWatermarPng-8    	     200	   8197291 ns/op
BenchmarkWatermarWebp-8   	      30	  49360369 ns/op

Examples

import (
  "fmt"
  "os"
  "github.com/h2non/bimg/v2"
)
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 == 800 && size.Height == 600 {
  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")
}
Force resize

Force resize operation without preserving the aspect ratio:

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

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

size := bimg.Size(newImage)
if size.Width != 1000 || size.Height != 500 {
  fmt.Fprintln(os.Stderr, "Incorrect image size")
}
Custom colour space (black & white)
buffer, err := bimg.Read("image.jpg")
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

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

colourSpace, _ := bimg.ImageInterpretation(newImage)
if colourSpace != bimg.INTERPRETATION_B_W {
  fmt.Fprintln(os.Stderr, "Invalid colour space")
}
Custom options

See Options struct to discover all the available fields

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

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)
Watermark
buffer, err := bimg.Read("image.jpg")
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

watermark := bimg.Watermark{
  Text:       "Chuck Norris (c) 2315",
  Opacity:    0.25,
  Width:      200,
  DPI:        100,
  Margin:     150,
  Font:       "sans bold 12",
  Background: bimg.Color{255, 255, 255},
}

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

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

If you intend to apply multiple transformations to the same image, you should use the ImageTransformation system which will decode the image once and lets you work on this decoded image as long as you please.

// read the raw data
buffer, err := bimg.Read("image.jpg")
if err != nil {
  fmt.Fprintln(os.Stderr, err)
  return
}

// decode the image and prepare our transformation chain
it, err := bimg.NewImageTransformation(buffer)
if err != nil {
  fmt.Fprintln(os.Stderr, err)
  return
}

// crop the image to a specific width
err = it.Crop(bimg.CropOptions{Width: 300})
if err != nil {
  fmt.Fprintln(os.Stderr, err)
  return
}

// then flip it
err = it.Rotate(bimg.RotateOptions{Flip: true})
if err != nil {
  fmt.Fprintln(os.Stderr, err)
  return
}

// encode the image
newImage, err := it.Save(bimg.SaveOptions{})
if err != nil {
  fmt.Fprintln(os.Stderr, err)
  return
} 

// save the cropped and flipped image
bimg.Write("new.jpg", newImage)

Debugging

Run the process passing the DEBUG environment variable

DEBUG=bimg ./app

Enable libvips traces (note that a lot of data will be written in stdout):

VIPS_TRACE=1 ./app

You can also dump a core on failure, as John Cuppit said:

g_log_set_always_fatal(
                G_LOG_FLAG_RECURSION |
                G_LOG_FLAG_FATAL |
                G_LOG_LEVEL_ERROR |
                G_LOG_LEVEL_CRITICAL |
                G_LOG_LEVEL_WARNING );

Or set the G_DEBUG environment variable:

export G_DEBUG=fatal-warnings,fatal-criticals

API

See godoc reference for detailed API documentation.

Authors

Credits

People who recurrently contributed to improve bimg in some way.

Thank you!

License

MIT - Tomas Aparicio

views

Documentation

Index

Constants

View Source 
const (
	Make                    = "exif-ifd0-Make"
	Model                   = "exif-ifd0-Model"
	Orientation             = "exif-ifd0-Orientation"
	XResolution             = "exif-ifd0-XResolution"
	YResolution             = "exif-ifd0-YResolution"
	ResolutionUnit          = "exif-ifd0-ResolutionUnit"
	Software                = "exif-ifd0-Software"
	Datetime                = "exif-ifd0-DateTime"
	YCbCrPositioning        = "exif-ifd0-YCbCrPositioning"
	Compression             = "exif-ifd1-Compression"
	ExposureTime            = "exif-ifd2-ExposureTime"
	FNumber                 = "exif-ifd2-FNumber"
	ExposureProgram         = "exif-ifd2-ExposureProgram"
	ISOSpeedRatings         = "exif-ifd2-ISOSpeedRatings"
	ExifVersion             = "exif-ifd2-ExifVersion"
	DateTimeOriginal        = "exif-ifd2-DateTimeOriginal"
	DateTimeDigitized       = "exif-ifd2-DateTimeDigitized"
	ComponentsConfiguration = "exif-ifd2-ComponentsConfiguration"
	ShutterSpeedValue       = "exif-ifd2-ShutterSpeedValue"
	ApertureValue           = "exif-ifd2-ApertureValue"
	BrightnessValue         = "exif-ifd2-BrightnessValue"
	ExposureBiasValue       = "exif-ifd2-ExposureBiasValue"
	MeteringMode            = "exif-ifd2-MeteringMode"
	Flash                   = "exif-ifd2-Flash"
	FocalLength             = "exif-ifd2-FocalLength"
	SubjectArea             = "exif-ifd2-SubjectArea"
	MakerNote               = "exif-ifd2-MakerNote"
	SubSecTimeOriginal      = "exif-ifd2-SubSecTimeOriginal"
	SubSecTimeDigitized     = "exif-ifd2-SubSecTimeDigitized"
	ColorSpace              = "exif-ifd2-ColorSpace"
	PixelXDimension         = "exif-ifd2-PixelXDimension"
	PixelYDimension         = "exif-ifd2-PixelYDimension"
	SensingMethod           = "exif-ifd2-SensingMethod"
	SceneType               = "exif-ifd2-SceneType"
	ExposureMode            = "exif-ifd2-ExposureMode"
	WhiteBalance            = "exif-ifd2-WhiteBalance"
	FocalLengthIn35mmFilm   = "exif-ifd2-FocalLengthIn35mmFilm"
	SceneCaptureType        = "exif-ifd2-SceneCaptureType"
	GPSLatitudeRef          = "exif-ifd3-GPSLatitudeRef"
	GPSLatitude             = "exif-ifd3-GPSLatitude"
	GPSLongitudeRef         = "exif-ifd3-GPSLongitudeRef"
	GPSLongitude            = "exif-ifd3-GPSLongitude"
	GPSAltitudeRef          = "exif-ifd3-GPSAltitudeRef"
	GPSAltitude             = "exif-ifd3-GPSAltitude"
	GPSSpeedRef             = "exif-ifd3-GPSSpeedRef"
	GPSSpeed                = "exif-ifd3-GPSSpeed"
	GPSImgDirectionRef      = "exif-ifd3-GPSImgDirectionRef"
	GPSImgDirection         = "exif-ifd3-GPSImgDirection"
	GPSDestBearingRef       = "exif-ifd3-GPSDestBearingRef"
	GPSDestBearing          = "exif-ifd3-GPSDestBearing"
	GPSDateStamp            = "exif-ifd3-GPSDateStamp"
)

Common EXIF fields for data extraction

View Source 
const (
	// Quality defines the default JPEG quality to be used.
	Quality = 75
)
View Source 
const Version = "1.1.9"

Version represents the current package semantic version.

View Source 
const VipsMajorVersion = int(C.VIPS_MAJOR_VERSION)

VipsMajorVersion exposes the current libvips major version number

View Source 
const VipsMinorVersion = int(C.VIPS_MINOR_VERSION)

VipsMinorVersion exposes the current libvips minor version number

View Source 
const VipsVersion = string(C.VIPS_VERSION)

VipsVersion exposes the current libvips semantic version

Variables

View Source 
var ColorBlack = Color{0x00, 0x00, 0x00}

ColorBlack is a shortcut to black RGB color representation.

View Source 
var ColorWhite = Color{0xFF, 0xFF, 0xFF}

ColorWhite is a shortcut to white RGB color representation.

View Source 
var (
	// ErrExtractAreaParamsRequired defines a generic extract area error
	ErrExtractAreaParamsRequired = errors.New("extract area width/height params are required")
)
View Source 
var ImageTypes = map[ImageType]string{
	JPEG:   "jpeg",
	PNG:    "png",
	WEBP:   "webp",
	TIFF:   "tiff",
	GIF:    "gif",
	PDF:    "pdf",
	SVG:    "svg",
	HEIF:   "heif",
	AVIF:   "avif",
	JP2K:   "jp2k",
	JXL:    "jxl",
	MAGICK: "magick",
}

ImageTypes stores as pairs of image types supported and its alias names.

View Source 
var SupportedImageTypes = map[ImageType]SupportedImageType{}

SupportedImageTypes stores the optional image type supported by the current libvips compilation. Note: lazy evaluation as demand is required due to bootstrap runtime limitation with C/libvips world.

View Source 
var WatermarkFont = "sans 10"

WatermarkFont defines the default watermark font to be used.

Functions

func ColourspaceIsSupported 

func ColourspaceIsSupported(buf []byte) (bool, error)

ColourspaceIsSupported checks if the image colourspace is supported by libvips.

func DetermineImageTypeName 

func DetermineImageTypeName(buf []byte) string

DetermineImageTypeName determines the image type format by name (jpeg, png, webp or tiff)

func ImageTypeName 

func ImageTypeName(t ImageType) string

ImageTypeName is used to get the human friendly name of an image format.

func Initialize 

func Initialize()

Initialize is used to explicitly start libvips in thread-safe way. Only call this function if you have previously turned off libvips.

func IsSVGImage 

func IsSVGImage(buf []byte) bool

IsSVGImage returns true if the given buffer is a valid SVG image.

func IsTypeNameSupported 

func IsTypeNameSupported(t string) bool

IsTypeNameSupported checks if a given image type name is supported

func IsTypeNameSupportedSave 

func IsTypeNameSupportedSave(t string) bool

IsTypeNameSupportedSave checks if a given image type name is supported for saving

func IsTypeSupported 

func IsTypeSupported(t ImageType) bool

IsTypeSupported checks if a given image type is supported

func IsTypeSupportedSave 

func IsTypeSupportedSave(t ImageType) bool

IsTypeSupportedSave checks if a given image type is support for saving

func MaxSize 

func MaxSize() int

MaxSize returns maxSize.

func Read 

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

Read reads all the content of the given file path and returns it as byte buffer.

func SetMaxsize 

func SetMaxsize(s int) error

SetMaxSize sets maxSize.

func Shutdown 

func Shutdown()

Shutdown is used to shutdown libvips in a thread-safe way. You can call this to drop caches as well. If libvips was already initialized, the function is no-op

func VipsCacheDropAll 

func VipsCacheDropAll()

VipsCacheDropAll drops the vips operation cache, freeing the allocated memory.

func VipsCacheSetMax 

func VipsCacheSetMax(maxCacheSize int)

VipsCacheSetMax sets the maximum number of operations to keep in the vips operation cache.

func VipsCacheSetMaxMem 

func VipsCacheSetMaxMem(maxCacheMem int)

VipsCacheSetMaxMem Sets the maximum amount of tracked memory allowed before the vips operation cache begins to drop entries.

func VipsDebugInfo 

func VipsDebugInfo()

VipsDebugInfo outputs to stdout libvips collected data. Useful for debugging.

func VipsIsTypeSupported 

func VipsIsTypeSupported(t ImageType) bool

VipsIsTypeSupported returns true if the given image type is supported by the current libvips compilation.

func VipsIsTypeSupportedSave 

func VipsIsTypeSupportedSave(t ImageType) bool

VipsIsTypeSupportedSave returns true if the given image type is supported by the current libvips compilation for the save operation.

func VipsVectorSetEnabled 

func VipsVectorSetEnabled(enable bool)

VipsVectorSetEnabled enables or disables SIMD vector instructions. This can give speed-up, but can also be unstable on some systems and versions.

func Write 

func Write(path string, buf []byte) error

Write writes the given byte buffer into disk to the given file path.

Types

type Color 

type Color struct {
	R, G, B uint8
}

Color represents a traditional RGB color scheme.

func (Color) RGBA 

func (c Color) RGBA() (r uint8, g uint8, b uint8, a uint8)

RGBA returns the color with full opacity.

type ColorWithAlpha 

type ColorWithAlpha struct {
	Color
	A uint8
}

ColorWithAlpha represents a traditional RGBA color scheme. It uses Color as base for easier reusability of already defined colors.

func (ColorWithAlpha) RGBA 

func (c ColorWithAlpha) RGBA() (r uint8, g uint8, b uint8, a uint8)

RGBA returns the color with the specified alpha value.

type CropOptions 

type CropOptions struct {
	Width   int
	Height  int
	Gravity Gravity
}

type Direction 

type Direction int

Direction represents the image direction value. 

const (
	// Horizontal represents the orizontal image direction value.
	Horizontal Direction = C.VIPS_DIRECTION_HORIZONTAL
	// Vertical represents the vertical image direction value.
	Vertical Direction = C.VIPS_DIRECTION_VERTICAL
)

type EXIF 

type EXIF struct {
	Make                    string
	Model                   string
	Orientation             int
	XResolution             string
	YResolution             string
	ResolutionUnit          int
	Software                string
	Datetime                string
	YCbCrPositioning        int
	Compression             int
	ExposureTime            string
	FNumber                 string
	ExposureProgram         int
	ISOSpeedRatings         int
	ExifVersion             string
	DateTimeOriginal        string
	DateTimeDigitized       string
	ComponentsConfiguration string
	ShutterSpeedValue       string
	ApertureValue           string
	BrightnessValue         string
	ExposureBiasValue       string
	MeteringMode            int
	Flash                   int
	FocalLength             string
	SubjectArea             string
	MakerNote               string
	SubSecTimeOriginal      string
	SubSecTimeDigitized     string
	ColorSpace              int
	PixelXDimension         int
	PixelYDimension         int
	SensingMethod           int
	SceneType               string
	ExposureMode            int
	WhiteBalance            int
	FocalLengthIn35mmFilm   int
	SceneCaptureType        int
	GPSLatitudeRef          string
	GPSLatitude             string
	GPSLongitudeRef         string
	GPSLongitude            string
	GPSAltitudeRef          string
	GPSAltitude             string
	GPSSpeedRef             string
	GPSSpeed                string
	GPSImgDirectionRef      string
	GPSImgDirection         string
	GPSDestBearingRef       string
	GPSDestBearing          string
	GPSDateStamp            string
}

EXIF image metadata

type EmbedOptions 

type EmbedOptions struct {
	Width      int
	Height     int
	Extend     Extend
	Background RGBAProvider
}

type Extend 

type Extend int

Extend represents the image extend mode, used when the edges of an image are extended, you can specify how you want the extension done. See: https://libvips.github.io/libvips/API/current/libvips-conversion.html#VIPS-EXTEND-BACKGROUND:CAPS 

const (
	// ExtendBlack extend with black (all 0) pixels mode.
	ExtendBlack Extend = C.VIPS_EXTEND_BLACK
	// ExtendCopy copy the image edges.
	ExtendCopy Extend = C.VIPS_EXTEND_COPY
	// ExtendRepeat repeat the whole image.
	ExtendRepeat Extend = C.VIPS_EXTEND_REPEAT
	// ExtendMirror mirror the whole image.
	ExtendMirror Extend = C.VIPS_EXTEND_MIRROR
	// ExtendWhite extend with white (all bits set) pixels.
	ExtendWhite Extend = C.VIPS_EXTEND_WHITE
	// ExtendBackground with colour from the background property.
	ExtendBackground Extend = C.VIPS_EXTEND_BACKGROUND
	// ExtendLast extend with last pixel.
	ExtendLast Extend = C.VIPS_EXTEND_LAST
)

type ExtractOptions 

type ExtractOptions struct {
	Left   int
	Top    int
	Width  int
	Height int
}

type GaussianBlurOptions 

type GaussianBlurOptions struct {
	Sigma   float64
	MinAmpl float64
}

GaussianBlurOptions represents the gaussian image transformation values.

type Gravity 

type Gravity int

Gravity represents the image gravity value. 

const (
	// GravityCentre represents the centre value used for image gravity orientation.
	GravityCentre Gravity = iota
	// GravityNorth represents the north value used for image gravity orientation.
	GravityNorth
	// GravityEast represents the east value used for image gravity orientation.
	GravityEast
	// GravitySouth represents the south value used for image gravity orientation.
	GravitySouth
	// GravityWest represents the west value used for image gravity orientation.
	GravityWest
	// GravitySmart enables libvips Smart Crop algorithm for image gravity orientation.
	GravitySmart
)

type Image 

type Image struct {
	// contains filtered or unexported fields
}

Image allows the sequential transformation of an image. All transformation steps are done in memory on a raw buffer. The image is not encoded until it is saved.

func NewImageFromBuffer 

func NewImageFromBuffer(buf []byte) (*Image, error)

NewImageFromBuffer creates a new image transformation from the given buffer. The file type is determined by the header of the buffer and the image is decoded according to that determined file type.

func NewImageFromFile 

func NewImageFromFile(filename string) (*Image, error)

NewImageFromFile loads the given file into a buffer and then loads it via NewImageFromBuffer.

func (*Image) AutoRotate 

func (it *Image) AutoRotate() error

AutoRotate performs rotation according to exif information within the image, turning a previous "virtual" rotation into a real one (that modifies pixel).

func (*Image) Blur 

func (it *Image) Blur(opts GaussianBlurOptions) error

Blur the image.

func (*Image) Brightness 

func (it *Image) Brightness(brightness float64) error

Brightness applies the given brightness value to the current image.

func (*Image) ChangeColorspace 

func (it *Image) ChangeColorspace(interpretation Interpretation) error

Change (or enforce) the given interpretation/colorspace.

func (*Image) Clone 

func (it *Image) Clone() *Image

Clone the current transformation state. Performing further transformations will not manipulate the source it has been cloned from (and vice versa).

func (*Image) Close 

func (it *Image) Close()

Close explicitly closes the image and free up its resources. It may no longer be used afterwards.

func (*Image) Contrast 

func (it *Image) Contrast(contrast float64) error

Contrast applies the given contrast value to the current image.

func (*Image) Crop 

func (it *Image) Crop(opts CropOptions) error

Crop the current image to the specified Width and Height, if necessary. If the image is already smaller than the given dimensions, nothing is done.

func (*Image) Embed 

func (it *Image) Embed(opts EmbedOptions) error

Embed the image on the given background. The image will be centered.

func (*Image) Extract 

func (it *Image) Extract(opts ExtractOptions) error

Extract the given area from the image (removing everything outside that area).

func (*Image) Flatten 

func (it *Image) Flatten(background RGBAProvider) error

Flatten removes the alpha channel from the current image, replacing it with the given background.

func (*Image) FlipHorizontal 

func (it *Image) FlipHorizontal() error

FlipHorizontal transposes the image along the X axis, turning it from left to right.

func (*Image) FlipVertical 

func (it *Image) FlipVertical() error

FlipVertical transposes the image along the Y axis, turning it from top to bottom.

func (*Image) Gamma 

func (it *Image) Gamma(gamma float64) error

Gamma applies the given gamma value to the current image.

func (*Image) Metadata 

func (it *Image) Metadata() ImageMetadata

Metadata returns the metadata of the image.

func (*Image) Resize 

func (it *Image) Resize(opts ResizeOptions) error

Resize the current image buffer according to the given options. Depending on the selected mode, aspect ratio is honored or ignored.

If neither Height nor Width are specified, both are set to the current dimensions of the image.

If only Height or Width is specified, the other is calculated from the 

current image dimensions, treating the specified dimension as a constraint.

func (*Image) Rotate 

func (it *Image) Rotate(angle int) error

Rotate the image by the given degree clockwise.

func (*Image) Save 

func (it *Image) Save(opts SaveOptions) ([]byte, error)

Save the image to a buffer, encoding it in the process. If no image type is specified, the image type from the initial image will be used (so if it was a JPEG before, it will be a JPEG again).

If no Quality or Compression levels are set, default values are used. Those are a quality level of 75% and a compression level of 6.

func (*Image) Sharpen 

func (it *Image) Sharpen(opts SharpenOptions) error

Sharpen the image.

func (*Image) Size 

func (it *Image) Size() ImageSize

Size returns the dimensions of the current image.

func (*Image) Trim 

func (it *Image) Trim(opts TrimOptions) error

Trim the image in regards to a given color and threshold. It will look for the specified color (within the given threshold) from the border of the image inwards and find the "borders" to a different colors to determine how to cut the image.

func (*Image) WatermarkImage 

func (it *Image) WatermarkImage(opts WatermarkImageOptions) error

WatermarkImage puts an image on top of the image.

func (*Image) WatermarkText 

func (it *Image) WatermarkText(opts WatermarkOptions) error

WatermarkText adds a text on top of the image.

type ImageMetadata 

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

ImageMetadata represents the basic metadata fields

func Metadata 

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

Metadata returns the image metadata (size, type, alpha channel, profile, EXIF orientation...).

type ImageSize 

type ImageSize struct {
	Width  int
	Height int
}

ImageSize represents the image width and height values

func Size 

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

Size returns the image size by width and height pixels.

type ImageType 

type ImageType int

ImageType represents an image type value. 

const (
	// UNKNOWN represents an unknown image type value.
	UNKNOWN ImageType = C.UNKNOWN
	// JPEG represents the JPEG image type.
	JPEG ImageType = C.JPEG
	// WEBP represents the WEBP image type.
	WEBP ImageType = C.WEBP
	// PNG represents the PNG image type.
	PNG ImageType = C.PNG
	// TIFF represents the TIFF image type.
	TIFF ImageType = C.TIFF
	// GIF represents the GIF image type.
	GIF ImageType = C.GIF
	// PDF represents the PDF type.
	PDF ImageType = C.PDF
	// SVG represents the SVG image type.
	SVG ImageType = C.SVG
	// HEIF represents the HEIC/HEIF/HVEC image type
	HEIF ImageType = C.HEIF
	// AVIF represents the AVIF image type.
	AVIF ImageType = C.AVIF
	// JP2K represents the JPEG 2000 image type.
	JP2K ImageType = C.JP2K
	// JXL represents the JPEG XL image type.
	JXL ImageType = C.JXL
	// MAGICK represents the libmagick compatible generic image type.
	MAGICK ImageType = C.MAGICK
)

func DetermineImageType 

func DetermineImageType(buf []byte) ImageType

DetermineImageType determines the image type format (jpeg, png, webp or tiff)

type Interpolator 

type Interpolator int

Interpolator represents the image interpolation value. 

const (
	// Bicubic interpolation value.
	Bicubic Interpolator = iota
	// Bilinear interpolation value.
	Bilinear
	// Nohalo interpolation value.
	Nohalo
	// Nearest neighbour interpolation value.
	Nearest
)

func (Interpolator) String 

func (i Interpolator) String() string

type Interpretation 

type Interpretation int

Interpretation represents the image interpretation type. See: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation 

const (
	// InterpretationError points to the libvips interpretation error type.
	InterpretationError Interpretation = C.VIPS_INTERPRETATION_ERROR
	// InterpretationMultiband points to its libvips interpretation equivalent type.
	InterpretationMultiband Interpretation = C.VIPS_INTERPRETATION_MULTIBAND
	// InterpretationBW points to its libvips interpretation equivalent type.
	InterpretationBW Interpretation = C.VIPS_INTERPRETATION_B_W
	// InterpretationCMYK points to its libvips interpretation equivalent type.
	InterpretationCMYK Interpretation = C.VIPS_INTERPRETATION_CMYK
	// InterpretationRGB points to its libvips interpretation equivalent type.
	InterpretationRGB Interpretation = C.VIPS_INTERPRETATION_RGB
	// InterpretationSRGB points to its libvips interpretation equivalent type.
	InterpretationSRGB Interpretation = C.VIPS_INTERPRETATION_sRGB
	// InterpretationRGB16 points to its libvips interpretation equivalent type.
	InterpretationRGB16 Interpretation = C.VIPS_INTERPRETATION_RGB16
	// InterpretationGREY16 points to its libvips interpretation equivalent type.
	InterpretationGREY16 Interpretation = C.VIPS_INTERPRETATION_GREY16
	// InterpretationScRGB points to its libvips interpretation equivalent type.
	InterpretationScRGB Interpretation = C.VIPS_INTERPRETATION_scRGB
	// InterpretationLAB points to its libvips interpretation equivalent type.
	InterpretationLAB Interpretation = C.VIPS_INTERPRETATION_LAB
	// InterpretationXYZ points to its libvips interpretation equivalent type.
	InterpretationXYZ Interpretation = C.VIPS_INTERPRETATION_XYZ
)

func ImageInterpretation 

func ImageInterpretation(buf []byte) (Interpretation, error)

ImageInterpretation returns the image interpretation type. See: https://libvips.github.io/libvips/API/current/VipsImage.html#VipsInterpretation

type Kernel 

type Kernel int

resampling kernels 

const (
	//The default chosen by VIPS.
	DefaultKernel Kernel = iota

	//The nearest pixel to the point.
	NearestKernel

	//Convolve with a triangle filter.
	LinearKernel

	//Convolve with a cubic filter.
	CubicKernel

	//Convolve with a Mitchell kernel.
	MitchellKernel

	//Convolve with a two-lobe Lanczos kernel.
	Lanczos2Kernel

	//Convolve with a three-lobe Lanczos kernel.
	Lanczos3Kernel

	LastKernel
)

type RGBAProvider 

type RGBAProvider interface {
	RGBA() (r uint8, g uint8, b uint8, a uint8)
}

RGBAProvider defines the interface required to get RGBA compatible color channels.

type ResizeMode 

type ResizeMode int

ResizeMode defines how the resize operation should be performed. 

const (
	// The dimensions will be enforced, no matter the aspect ratio.
	ResizeModeForce ResizeMode = iota
	// The dimensions will not be exceeded while honoring the aspect ratio.
	ResizeModeFit
	// One dimension will not be exceeded. The image will be *at least* as big
	// as the desired dimensions, while the aspect ratio is kept.
	ResizeModeFitUp
)

func (ResizeMode) String 

func (rm ResizeMode) String() string

type ResizeOptions 

type ResizeOptions struct {
	Height         int
	Width          int
	Top            int
	Left           int
	Zoom           int
	Mode           ResizeMode
	Interpolator   Interpolator
	Kernel         Kernel
	Interpretation Interpretation
}

type SaveOptions 

type SaveOptions vipsSaveOptions

type SharpenOptions 

type SharpenOptions struct {
	Radius int
	X1     float64
	Y2     float64
	Y3     float64
	M1     float64
	M2     float64
}

SharpenOptions represents the image sharp transformation options.

type SupportedImageType 

type SupportedImageType struct {
	Load bool
	Save bool
}

SupportedImageType represents whether a type can be loaded and/or saved by the current libvips compilation.

func IsImageTypeSupportedByVips 

func IsImageTypeSupportedByVips(t ImageType) SupportedImageType

IsImageTypeSupportedByVips returns true if the given image type is supported by current libvips compilation.

type TrimOptions 

type TrimOptions struct {
	Background RGBAProvider
	Threshold  float64
}

type VipsMemoryInfo 

type VipsMemoryInfo struct {
	Memory          int64
	MemoryHighwater int64
	Allocations     int64
}

VipsMemoryInfo represents the memory stats provided by libvips.

func VipsMemory 

func VipsMemory() VipsMemoryInfo

VipsMemory gets memory info stats from libvips (cache size, memory allocs...)

type WatermarkImage 

type WatermarkImage struct {
	Left    int
	Top     int
	Buf     []byte
	Opacity float32
}

WatermarkImage represents the image-based watermark supported options.

type WatermarkImageOptions 

type WatermarkImageOptions struct {
	Left    int
	Top     int
	Image   *Image
	Opacity float32
}

type WatermarkOptions 

type WatermarkOptions struct {
	Width       int
	DPI         int
	Margin      int
	Opacity     float32
	NoReplicate bool
	Text        string
	Font        string
	Background  RGBAProvider
}

WatermarkOptions represents the text-based watermark supported options.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.