A lightning fast image processing and resizing library for Go

Overview

govips

GoDoc Go Report Card GitHub release (latest SemVer) License Build Status Coverage Status

A lightning fast image processing and resizing library for Go

This package wraps the core functionality of libvips image processing library by exposing all image operations on first-class types in Go.

Libvips is generally 4-8x faster than other graphics processors such as GraphicsMagick and ImageMagick. Check the benchmark: Speed and Memory Use

The intent for this is to enable developers to build extremely fast image processors in Go, which is suited well for concurrent requests.

Requirements

  • libvips 8.10+
  • C compatible compiler such as gcc 4.6+ or clang 3.0+
  • Go 1.14+

Dependencies

MacOS

Use homebrew to install vips and pkg-config:

brew install vips pkg-config

Ubuntu

You need at least libvips 8.10.2 to work with govips. Groovy (20.10) repositories have the latest version. However on Bionic (18.04) and Focal (20.04), you need to install libvips and dependencies from a backports repository:

sudo add-apt-repository ppa:tonimelisma/ppa

Then:

sudo apt -y install libvips-dev

Windows

The recommended approach on Windows is to use Govips via WSL and Ubuntu.

If you need to run Govips natively on Windows, it's not difficult but will require some effort. We don't have a recommended environment or setup at the moment. Windows is also not in our list of CI/CD targets so Govips is not regularly tested for compatibility. If you would be willing to setup and maintain a robust CI/CD Windows environment, please open a PR, we would be pleased to accept your contribution and support Windows as a platform.

Installation

go get -u github.com/davidbyttow/govips/v2/vips

MacOS note

On MacOS, govips may not compile without first setting an environment variable:

export CGO_CFLAGS_ALLOW="-Xpreprocessor"

Example usage

package main

import (
	"fmt"
	"io/ioutil"
	"os"

	"github.com/davidbyttow/govips/v2/vips"
)

func checkError(err error) {
	if err != nil {
		fmt.Println("error:", err)
		os.Exit(1)
	}
}

func main() {
	vips.Startup(nil)
	defer vips.Shutdown()

	image1, err := vips.NewImageFromFile("input.jpg")
	checkError(err)

	// Rotate the picture upright and reset EXIF orientation tag
	err = image1.AutoRotate()
	checkError(err)

	ep := vips.NewDefaultJPEGExportParams()
	image1bytes, _, err := image1.Export(ep)
	err = ioutil.WriteFile("output.jpg", image1bytes, 0644)
	checkError(err)

}

See examples/ folder for more examples.

Running tests

$ make test

Contributing

Feel free to file issues or create pull requests. See this guide on contributing for more information.

Credits

Thanks to:

License

MIT - David Byttow

Issues
  • Add Transform ICC Profile API

    Add Transform ICC Profile API

    I previously asked about adding support for transforming images between ICC profiles and it was suggested that suggested I make a pull request. I was able to get the vips_icc_transform function working with an ICC profile that I supplied externally. If you have a Mac, the built-in color profiles are located at /System/Library/ColorSync/Profiles/.

    I was able to take an image with an embedded Display P3 color profile and transform it to both an sRGB version and a Display P3 version without breaking it.

    Please let me know what you think and if you have any feedback!

    opened by AttilaTheFun 21
  • Add support for Magick loader and most loading parameters.

    Add support for Magick loader and most loading parameters.

    I was trying to process some animated GIFs - which are supported by libvips - but realized that doing so requires some changes in this library: 1) passing parameters to loaders, 2) extracting some additional metadata from images (e.g. the number of pages), and 3) supporting the magick writer.

    I started taking a stab at (1), the only parameter that's missing is the "background" for PDF (I may add it - didn't want to figure out how it works just yet). While I was at it I also added the ability to use magick as loader.

    I'll add tests of course, but I wanted to see if this PR may be accepted and agree on design first.

    opened by ibrt 12
  • Resized image file size 20% to 40% larger than

    Resized image file size 20% to 40% larger than "sharp" of Node.js

    govips produces 20% - 40% larger image file sizes than sharp (node equivalent) does for the same image dimensions and the same Lanczos3 kernel.

    Please check if govips is producing the optimal file size since both are using the same libvips backend.

    Thanks.

    opened by sann1918 12
  • Adds support for loading parameters

    Adds support for loading parameters

    Inspired by: https://github.com/davidbyttow/govips/pull/155

    However, this doesn't use libvips options yet. My intent is to likely switch to using VImage options (rather than C vararg functions) for import and export parameters, but I wanted to get this exposed and working first.

    opened by davidbyttow 11
  • ImportParams proof of concept

    ImportParams proof of concept

    Related to https://github.com/davidbyttow/govips/issues/147

    I created ImportParams struct with fields:

    • Fail
    • AutoRotate
    • Shrink

    All of them is optional and by default don't set on ...load_buffer call. By the same way can be added any other optional field.

    opened by bozaro 11
  • Add mozjpeg equivalent parameters to save

    Add mozjpeg equivalent parameters to save

    jcupitt explains the mozjpeg parameters in this comment: https://github.com/libvips/libvips/issues/1422#issuecomment-530032329

    Additionally, look for references to mozjpeg in the documentation for vips_jpegsave(): https://libvips.github.io/libvips/API/current/VipsForeignSave.html#VipsForeignJpegSubsample

    These changes improved jpeg compression for my test image, especially with the addition of overshoot_deringing when compressing a screenshot that includes text.

    opened by sandro 8
  • NewImageFromBuffer Not Understand Image Format

    NewImageFromBuffer Not Understand Image Format

    Hi there,

    import "bytes"
    import "image"
    import "image/color"
    import "image/png"
    import "image/draw"
    
    im := image.NewRGBA(image.Rect(0, 0, 100, 100))
    draw.Draw(im, im.Bounds(), image.NewUniform(color.NRGBA{255, 0, 0, 255}), image.ZP, draw.Src)
    var buff bytes.Buffer
    err := png.Encode(&buff, im)
    
    vipsImage, err := vips.NewImageFromBuffer(buff.Bytes())
    

    [govips.info] failed to understand image format size=26149

    Any suggestions how to solve this?

    opened by phlqp 8
  • Memory Leak

    Memory Leak

    I am having a memory leak with govips. Any suggestions how to solve this?

    after several images

    Allocated Memory = 104 MiB	Total Allocated Memory = 144 MiB	System Memory = 134 MiB	Number of GC = 7
    VIPS Allocated Memory = 114 MiB	VIPS Total Allocated Memory = 121 MiB	VIPS Memory Allocations = 2 
    
    Allocated Memory = 104 MiB	Total Allocated Memory = 288 MiB	System Memory = 134 MiB	Number of GC = 15
    VIPS Allocated Memory = 171 MiB	VIPS Total Allocated Memory = 178 MiB	VIPS Memory Allocations = 3 
    

    Originally posted by @evanoberholster in https://github.com/davidbyttow/govips/issues/44#issuecomment-435683155

    bug help wanted 
    opened by evanoberholster 8
  • ImportParams missing  during LoadImageFromBuffer

    ImportParams missing during LoadImageFromBuffer

    I got error:

     value "0.000000" of type 'gdouble' is invalid or out of range for property 'dpi' of type 'gdouble'
    

    when I load a pdf file with dpi params

    my code

    // init some params
    pdfImportParams := vips.NewImportParams()
    pdfImportParams.Density.Set(300)
    pdfImportParams.Page.Set(0)
    // get a file
    buf, err := ioutil.ReadFile("foo.pdf")
    checkError(err)
    image1, err := vips.LoadImageFromBuffer(buf, pdfImportParams)
    // write to jpg
    ep := vips.NewJpegExportParams()
    imageBytes, _, err := image1.ExportJpeg(ep)
    err = ioutil.WriteFile("bar.jpg", imageBytes, 0644)
    checkError(err)
    

    the "Density(dpi)" didn't work

    My goal

    pdf to jpg with dpi params such as

    vips pdfload foo.pdf bar.jpg --dpi=300 --page=1
    

    bug point

    if err := C.load_from_buffer(&importParams, unsafe.Pointer(&src[0]), C.size_t(len(src))); err != 0 {
         return nil, ImageTypeUnknown, handleImageError(importParams.outputImage)
    }
    

    this code located in "vips/foreign.go" line 253

    I am new to both Libvips and Golang, I don't know how to lock and fix this problem

    opened by dark-wind 7
  • TIFF page selection

    TIFF page selection

    Govips seems to have a basic support for TIFF images. However, an important feature is missing: the possibility to choose an arbitrary page (for the multipage tiffs) and then extract, transform or save that page. Libvips seems to have the necessary methods (at least based on https://github.com/libvips/libvips/issues/775).

    Can this feature be easily added ?

    Thank you in advance! Best regards, SoftExpert

    opened by SoftExpert 7
  • Govips panics on shutdown

    Govips panics on shutdown

    There's a randomly appearing bug where Govips appears to try to call a Go callback on shutdown() even after the Go runtime has already exited. I've also reported it to the golang tracker and it seems it might be a bug in the macOS implementation of go:

    https://github.com/golang/go/issues/42465

    It's annoying and unprofessional, to get a stack trace when your program exits. None the less it's not strictly breaking anything.

    Is there anything we might do in Govips to prevent this behaviour? Are there any callbacks registered to be run on exit? It's causing our CI tests to fail for macOS at the moment for both macOS versions:

    https://github.com/davidbyttow/govips/runs/1565811797

    https://github.com/davidbyttow/govips/runs/1565999906

    1727
    
    1728
    goroutine 1 [running, locked to thread]:
    1729
    runtime.throw(0x42d46ca, 0x2d)
    1730
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/panic.go:1116 +0x72 fp=0xc000105da0 sp=0xc000105d70 pc=0x403b212
    1731
    runtime.exitsyscall()
    1732
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/proc.go:3239 +0x22c fp=0xc000105dd0 sp=0xc000105da0 pc=0x406d94c
    1733
    runtime.cgocallbackg(0x0)
    1734
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/cgocall.go:202 +0xa5 fp=0xc000105e38 sp=0xc000105dd0 pc=0x4008185
    1735
    runtime.cgocallback_gofunc(0x405a74c, 0x40738e0, 0xc000105eb8, 0x43138b0)
    1736
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/asm_amd64.s:794 +0x9b fp=0xc000105e58 sp=0xc000105e38 pc=0x4071ffb
    1737
    runtime.asmcgocall(0x40738e0, 0xc000105eb8)
    1738
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/asm_amd64.s:641 +0x42 fp=0xc000105e60 sp=0xc000105e58 pc=0x4071e82
    1739
    runtime.libcCall(0x40738e0, 0xc000105eb8, 0x431dcc0)
    1740
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/sys_darwin.go:46 +0x6c fp=0xc000105e90 sp=0xc000105e60 pc=0x405a74c
    1741
    runtime.exit(0x0)
    1742
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/sys_darwin.go:256 +0x31 fp=0xc000105eb8 sp=0xc000105e90 pc=0x406f1d1
    1743
    syscall.Exit(0x0)
    1744
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/runtime.go:64 +0x1b fp=0xc000105ed0 sp=0xc000105eb8 pc=0x406dd1b
    1745
    os.Exit(0x0)
    1746
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/os/proc.go:67 +0x30 fp=0xc000105ee8 sp=0xc000105ed0 pc=0x409bfd0
    1747
    main.main()
    1748
    	_testmain.go:339 +0x1d3 fp=0xc000105f88 sp=0xc000105ee8 pc=0x4249213
    1749
    runtime.main()
    1750
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/proc.go:204 +0x209 fp=0xc000105fe0 sp=0xc000105f88 pc=0x403da89
    1751
    runtime.goexit()
    1752
    	/Users/runner/hostedtoolcache/go/1.15.6/x64/src/runtime/asm_amd64.s:1374 +0x1 fp=0xc000105fe8 sp=0xc000105fe0 pc=0x4072281
    1753
    
    1754
    goroutine 31 [select]:
    1755
    github.com/davidbyttow/govips/v2/vips.collectStats.func1(0xc000016e28, 0xc0000205a0)
    1756
    	/Users/runner/work/govips/govips/vips/stats.go:28 +0xd9
    1757
    created by github.com/davidbyttow/govips/v2/vips.collectStats
    1758
    	/Users/runner/work/govips/govips/vips/stats.go:26 +0xbd
    1759
    
    opened by tonimelisma 7
  • Fix ImageType for AVIF

    Fix ImageType for AVIF

    The ImageTypeAVIF was set to "heif", but should be "avif". Looks like a copy/paste error, introduced with https://github.com/davidbyttow/govips/pull/190

    opened by gutweiler 1
  • Alpha mask for an image

    Alpha mask for an image

    How to create an alpha mask - basically an image having black pixels which are transparent and white for the ones which have 0 transparency - so creating an image from the alpha channel of the given image?

    opened by Ruchika-K 0
  • Possible wrong logic for default configs fallbacks

    Possible wrong logic for default configs fallbacks

    Not sure if this was intended, but checking if config.x >= 0 to set the user settings, and otherwise fallback to default would mean I could set every setting to 0*. Was this supposed to be = 0 check instead of >= 0? If 0 is unlimited, then -1 would be the fallback? 🤔

    https://github.com/davidbyttow/govips/blob/19c388d12dab283becd7068b7a134740c18216b6/vips/govips.go#L110-L132

    • If I set everything as 0 I get [govips.info] vips 8.12.2 started with concurrency=16 cache_max_files=0 cache_max_mem=0 cache_max=0
    opened by Delicious-Bacon 0
  • signal: segmentation fault

    signal: segmentation fault

    I had a Go project running around 250 concurrent image processing routines and had a crash with the only message being signal: segmentation fault.

    I am running Ubuntu 22.04. on WSL2.

    I have seen this note on memory. Can it be related to that? If so, how/where would I set the MALLOC_ARENA_MAX?

    Something else that might be interesting is the ulimit -a output so I'll dump it here:

    ulimit -a
    real-time non-blocking time  (microseconds, -R) unlimited
    core file size              (blocks, -c) 0
    data seg size               (kbytes, -d) unlimited
    scheduling priority                 (-e) 0
    file size                   (blocks, -f) unlimited
    pending signals                     (-i) 63824
    max locked memory           (kbytes, -l) 65536
    max memory size             (kbytes, -m) unlimited
    open files                          (-n) 65535
    pipe size                (512 bytes, -p) 8
    POSIX message queues         (bytes, -q) 819200
    real-time priority                  (-r) 0
    stack size                  (kbytes, -s) 8192
    cpu time                   (seconds, -t) unlimited
    max user processes                  (-u) 63824
    virtual memory              (kbytes, -v) unlimited
    file locks                          (-x) unlimited
    
    opened by Delicious-Bacon 3
  • WIP: implement vips_image_new_from_file

    WIP: implement vips_image_new_from_file

    This enables creating new image object directly from file path, using vips_image_new_from_file:

    Below is the go bench of NewImageFromFile against the master branch. The memory difference B/op is very noticeable. The speed maybe slightly slower, presumably due to disk seek (instead of all loaded in memory).

    (base) ➜  govips git:(master) CGO_CFLAGS_ALLOW=.* CGO_LDFLAGS_ALLOW=.* go test -bench=NewImageFromFile -benchtime=30s -benchmem ./examples/thumbnail
    goos: darwin
    goarch: amd64
    pkg: github.com/davidbyttow/govips/v2/examples/thumbnail
    cpu: Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz
    BenchmarkNewImageFromFile-4           91         388221588 ns/op         2600845 B/op        234 allocs/op
    PASS
    ok      github.com/davidbyttow/govips/v2/examples/thumbnail     36.420s
    
    (base) ➜  govips git:(vips_new_image) CGO_CFLAGS_ALLOW=.* CGO_LDFLAGS_ALLOW=.* go test -bench=NewImageFromFile -benchtime=30s -benchmem ./examples/thumbnail
    goos: darwin
    goarch: amd64
    pkg: github.com/davidbyttow/govips/v2/examples/thumbnail
    cpu: Intel(R) Core(TM) i5-7360U CPU @ 2.30GHz
    BenchmarkNewImageFromFile-4           90         395057470 ns/op          261382 B/op        201 allocs/op
    PASS
    ok      github.com/davidbyttow/govips/v2/examples/thumbnail     36.167s
    

    However this relies on libvips's VIPS_META_LOADER to determine image type, instead of govips's DetermineImageType, which potentially introduces different behaviour for edge cases.

    Tests passing under Linux, but TestImage_DrawRectRGBA seems to be failing under MacOS I am not sure why.

    #289

    opened by cshum 1
  • LoadImageFromFile should use native libvips implementation

    LoadImageFromFile should use native libvips implementation

    This is more of a feature request - but I think there are multiple use-cases where it would be beneficial to use the native libvips implementation for loading from a file. The current implementation reads the whole file into memory and calls LoadImageFromBuffer.

    In our case, we are using govips as part of the detect pipeline for uploaded user media which could be one of multiple types. Natively, libvips only reads the file header to return the metadata. In the case of a large file (e.g. video of 600MB), and a cloud environment where disk throughput is suboptimal (capped at 200MB/s) it can take a substantial amount of time to fetch the file meta (or determine that the file is not supported). We reverted to calling the vipsheader CLI here to save time.

    Also, loading the whole file into memory seems unnecessary as libvips has optimizations to not load the whole file at once where possible in order to be more RAM efficient.

    opened by ugljesas 3
Releases(v2.11.0)
  • v2.11.0(Mar 17, 2022)

    Bug fixes and improvements

    • Fixes various animated GIF issues (thanks @Elad-Laufer and @cshum)
    • Fixes DPI param for svg and PDF (thanks @JMontupet)

    What's Changed

    • Pages() - Always return 1 for JP2K by @Elad-Laufer in https://github.com/davidbyttow/govips/pull/252
    • RemoveMetadata() - Retain page metadata by @Elad-Laufer in https://github.com/davidbyttow/govips/pull/253
    • Animated GIF support for load thumbnail by @cshum in https://github.com/davidbyttow/govips/pull/258
    • Animated GIF support for ExtractArea by @cshum in https://github.com/davidbyttow/govips/pull/259
    • Bump simple-get from 4.0.0 to 4.0.1 in /examples/tiff by @dependabot in https://github.com/davidbyttow/govips/pull/261
    • Animated GIF support for Embed, EmbedBackground by @cshum in https://github.com/davidbyttow/govips/pull/260
    • Set and Get PageDelay for animated GIF by @cshum in https://github.com/davidbyttow/govips/pull/262
    • fix typo by @4ricci in https://github.com/davidbyttow/govips/pull/267
    • Update example_mozjepg_image.go to close image by @WeibingChen17 in https://github.com/davidbyttow/govips/pull/271
    • Default to using gifsave for libvips >= 8.12.0 by @vansante in https://github.com/davidbyttow/govips/pull/269
    • fix dpi/density param for svg and pdf (#203) by @JMontupet in https://github.com/davidbyttow/govips/pull/268

    New Contributors

    • @dependabot made their first contribution in https://github.com/davidbyttow/govips/pull/261
    • @4ricci made their first contribution in https://github.com/davidbyttow/govips/pull/267
    • @WeibingChen17 made their first contribution in https://github.com/davidbyttow/govips/pull/271
    • @JMontupet made their first contribution in https://github.com/davidbyttow/govips/pull/268

    Full Changelog: https://github.com/davidbyttow/govips/compare/v2.10.0...v2.11.0

    Source code(tar.gz)
    Source code(zip)
  • v2.10.0(Jan 17, 2022)

    New functionality

    • Animated GIF support (thanks @Elad-Laufer)
    • Simple pixelation filter (thanks @Elad-Laufer)
    • Adds image Replicate for repeating images (thanks @cshum)

    Bug fixes and improvements

    • Fixes macos-11 test failures

    What's Changed

    • Remove deprecated export functions by @Elad-Laufer in https://github.com/davidbyttow/govips/pull/242
    • Fix typos and shadowing by @Elad-Laufer in https://github.com/davidbyttow/govips/pull/241
    • implement vips_replicate by @cshum in https://github.com/davidbyttow/govips/pull/243
    • Revert "- remove deprecated export functions (#242)" by @davidbyttow in https://github.com/davidbyttow/govips/pull/244
    • Minor fixes based on PR #242, adds macos-12 golden snapshots by @davidbyttow in https://github.com/davidbyttow/govips/pull/245
    • Add simple (and naive) implementation of pixelate filter by @Elad-Laufer in https://github.com/davidbyttow/govips/pull/224
    • Animated GIF support by @Elad-Laufer in https://github.com/davidbyttow/govips/pull/246

    Full Changelog: https://github.com/davidbyttow/govips/compare/v2.9.0...v2.10.0

    Source code(tar.gz)
    Source code(zip)
  • v2.9.0(Dec 31, 2021)

    New functionality

    • GetPoint()
    • Create thumbnails straight from image or buffer (faster than loading image, then thumbnailing)
    • vips_embed implements extend background with color
    • TransformICC()

    Bug fixes

    • Fix double-free in Label()
    Source code(tar.gz)
    Source code(zip)
  • v2.8.1(Dec 12, 2021)

  • v2.8.0(Dec 12, 2021)

    New functionality

    • loading parameters general support
    • JPEG2000 support
    • PNG export parameters support
    • getPoint()
    • Join()
    • ArrayJoin()

    Bug corrections

    • PNG loading fail parameter respected
    • WEBP ICC support
    • Some memory leak fixes
    Source code(tar.gz)
    Source code(zip)
  • v2.7.0(May 28, 2021)

  • v2.6.0(May 8, 2021)

    • FindTrim()
    • Insert()
    • Rank()
    • Improved BMP performance
    • Close() available again for manually closing images if GC can't keep up with your hyper-volume app
    • WEBP and GIF animation support

    A huge thank you to all the wonderful contributors!

    Source code(tar.gz)
    Source code(zip)
  • v2.5.0(Feb 19, 2021)

  • v2.4.0(Jan 6, 2021)

    New functionality:

    • Support vips_similarity (rotate and scale picture precisely, any angle)
    • Add support for converting govips images to golang image.Image objects
    • Smart cropping functionality (crop to the interesting parts of pictures)
    • Draw rectangles (draw_rect()) or start with an empty black image (black())
    • New format-specific export parameters which allow you to tune format-specific options

    Bug fixes:

    • Check if libvips compiled with ICC profile support before attempting to use it
    • Compress TIFF lossless by default
    Source code(tar.gz)
    Source code(zip)
  • v2.3.1(Dec 22, 2020)

  • v2.3.0(Dec 22, 2020)

  • v2.2.0(Dec 13, 2020)

  • v2.1.0(Nov 16, 2020)

    Version 2.1.0 comes with a couple of new features:

    • Logging - as verbose as you want it, to wherever you want it (not just stderr!)
    • Logging now consolidates all of glib, libvips and govips into one channel
    • imageRef.Close() is deprecated, it happens automatically nowadays

    In addition, we've got:

    • More, better examples and documentation
    • Better unit test coverage
    Source code(tar.gz)
    Source code(zip)
  • v2.0.2(Nov 2, 2020)

  • v2.0.1(Oct 28, 2020)

  • v2.0.0(Oct 27, 2020)

    Moving to version 2.0.0 due to breaking API changes. A lot of cleanup, new functionality merged from a fork, bug fixes, documentation etc.

    Source code(tar.gz)
    Source code(zip)
  • 0.2.0(Oct 2, 2017)

Owner
David Byttow
Tech Villain. Currently at Bridgewater. Formerly worked at Snapchat, Postmates, Google, Square, Secret, Amazon Game Studio, etc
David Byttow
Pure golang image resizing

This package is no longer being updated! Please look for alternatives if that bothers you. Resize Image resizing for the Go programming language with

Jan Schlicht 2.9k Aug 6, 2022
An image resizing server written in Go

picfit picfit is a reusable Go server to manipulate images (resize, thumbnail, etc.). It will act as a proxy on your storage engine and will be served

Florent Messa 1.7k Aug 9, 2022
Image resizing for the Go programming language with common interpolation methods

This package is no longer being updated! Please look for alternatives if that bothers you. Resize Image resizing for the Go programming language with

null 1 Dec 14, 2021
Fast and secure standalone server for resizing and converting remote images

imgproxy imgproxy is a fast and secure standalone server for resizing and converting remote images. The main principles of imgproxy are simplicity, sp

imgproxy 6.4k Aug 9, 2022
darkroom - An image proxy with changeable storage backends and image processing engines with focus on speed and resiliency.

Darkroom - Yet Another Image Proxy Introduction Darkroom combines the storage backend and the image processor and acts as an Image Proxy on your image

Gojek 194 Aug 3, 2022
Go package for fast high-level image processing powered by libvips C library

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

Tom 2k Aug 2, 2022
Image - This repository holds supplementary Go image librariesThis repository holds supplementary Go image libraries

Go Images This repository holds supplementary Go image libraries. Download/Insta

null 0 Jan 5, 2022
Fast, simple, scalable, Docker-ready HTTP microservice for high-level image processing

imaginary Fast HTTP microservice written in Go for high-level image processing backed by bimg and libvips. imaginary can be used as private or public

Tom 4.5k Aug 3, 2022
Cloud function + website for resizing, cropping and bordering images for pragalicious.com

Cloud function + website for resizing, cropping and bordering images for pragalicious.com

Ard Scheirlynck 0 Jan 23, 2022
Image processing library and rendering toolkit for Go.

blend Image processing library and rendering toolkit for Go. (WIP) Installation: This library is compatible with Go1. go get github.com/phrozen/blend

Guillermo Estrada 59 Dec 24, 2021
A library for basic image processing in Go.

Imaging Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.). All the image process

null 0 Nov 26, 2021
A library for basic image processing in Go.

Imaging Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.). All the image process

null 0 Nov 26, 2021
Storage and image processing server written in Go

Mort An S3-compatible image processing server written in Go. Still in active development. Features HTTP server Resize, Rotate, SmartCrop Convert (JPEG

Marcin Kaciuba 460 Jul 19, 2022
Image processing algorithms in pure Go

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

Anthony N. Simon 3.6k Jul 29, 2022
Imaging is a simple image processing package for Go

Imaging Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.). All the image process

Grigory Dryapak 4.3k Aug 7, 2022
An API which allows you to upload an image and responds with the same image, stripped of EXIF data

strip-metadata This is an API which allows you to upload an image and responds with the same image, stripped of EXIF data. How to run You need to have

Cristina Simionescu 0 Nov 25, 2021
Easily customizable Social image (or Open graph image) generator

fancycard Easily customizable Social image (or Open graph image) generator Built with Go, Gin, GoQuery and Chromedp Build & Run Simply, Clone this rep

Youngbin Han 4 Jan 14, 2022
Imgpreview - Tiny image previews for HTML while the original image is loading

imgpreview This is a Go program that generates tiny blurry previews for images t

Dmitry Chestnykh 8 May 22, 2022
A fast, correct image dithering library in Go.

dither is a library for dithering images in Go. It has many dithering algorithms built-in, and allows you to specify your own. Correctness is a

makeworld 251 Jul 25, 2022