An image proxy with changeable storage backends and image processing engines with focus on speed and resiliency.

darkroom

# Go Graphics

`gg` is a library for rendering 2D graphics in pure Go.

![Stars](http://i.imgur.com/CylQIJt.png)

## Installation

 go get -u github.com/fogleman/gg

Alternatively, you may use gopkg.in to grab a specific major-version:

 go get -u gopkg.in/fogleman/gg.v1

## Documentation

- godoc: https://godoc.org/github.com/fogleman/gg
- pkg.go.dev: https://pkg.go.dev/github.com/fogleman/gg?tab=doc

## Hello, Circle!

Look how easy!

```go
package main

import "github.com/fogleman/gg"

func main() {
 dc := gg.NewContext(1000, 1000)
 dc.DrawCircle(500, 500, 400)
 dc.SetRGB(0, 0, 0)
 dc.Fill()
 dc.SavePNG("out.png")
}
```

## Examples

There are [lots of examples](https://github.com/fogleman/gg/tree/master/examples) included. They're mostly for testing the code, but they're good for learning, too.

![Examples](http://i.imgur.com/tMFoyzu.png)

## Creating Contexts

There are a few ways of creating a context.

```go
NewContext(width, height int) *Context
NewContextForImage(im image.Image) *Context
NewContextForRGBA(im *image.RGBA) *Context
```

## Drawing Functions

Ever used a graphics library that didn't have functions for drawing rectangles
or circles? What a pain!

```go
DrawPoint(x, y, r float64)
DrawLine(x1, y1, x2, y2 float64)
DrawRectangle(x, y, w, h float64)
DrawRoundedRectangle(x, y, w, h, r float64)
DrawCircle(x, y, r float64)
DrawArc(x, y, r, angle1, angle2 float64)
DrawEllipse(x, y, rx, ry float64)
DrawEllipticalArc(x, y, rx, ry, angle1, angle2 float64)
DrawRegularPolygon(n int, x, y, r, rotation float64)
DrawImage(im image.Image, x, y int)
DrawImageAnchored(im image.Image, x, y int, ax, ay float64)
SetPixel(x, y int)

MoveTo(x, y float64)
LineTo(x, y float64)
QuadraticTo(x1, y1, x2, y2 float64)
CubicTo(x1, y1, x2, y2, x3, y3 float64)
ClosePath()
ClearPath()
NewSubPath()

Clear()
Stroke()
Fill()
StrokePreserve()
FillPreserve()
```

It is often desired to center an image at a point. Use `DrawImageAnchored` with `ax` and `ay` set to 0.5 to do this. Use 0 to left or top align. Use 1 to right or bottom align. `DrawStringAnchored` does the same for text, so you don't need to call `MeasureString` yourself.

## Text Functions

It will even do word wrap for you!

```go
DrawString(s string, x, y float64)
DrawStringAnchored(s string, x, y, ax, ay float64)
DrawStringWrapped(s string, x, y, ax, ay, width, lineSpacing float64, align Align)
MeasureString(s string) (w, h float64)
MeasureMultilineString(s string, lineSpacing float64) (w, h float64)
WordWrap(s string, w float64) []string
SetFontFace(fontFace font.Face)
LoadFontFace(path string, points float64) error
```

## Color Functions

Colors can be set in several different ways for your convenience.

```go
SetRGB(r, g, b float64)
SetRGBA(r, g, b, a float64)
SetRGB255(r, g, b int)
SetRGBA255(r, g, b, a int)
SetColor(c color.Color)
SetHexColor(x string)
```

## Stroke & Fill Options

```go
SetLineWidth(lineWidth float64)
SetLineCap(lineCap LineCap)
SetLineJoin(lineJoin LineJoin)
SetDash(dashes ...float64)
SetDashOffset(offset float64)
SetFillRule(fillRule FillRule)
```

## Gradients & Patterns

`gg` supports linear, radial and conic gradients and surface patterns. You can also implement your own patterns.

```go
SetFillStyle(pattern Pattern)
SetStrokeStyle(pattern Pattern)
NewSolidPattern(color color.Color)
NewLinearGradient(x0, y0, x1, y1 float64)
NewRadialGradient(x0, y0, r0, x1, y1, r1 float64)
NewConicGradient(cx, cy, deg float64)
NewSurfacePattern(im image.Image, op RepeatOp)
```

## Transformation Functions

```go
Identity()
Translate(x, y float64)
Scale(x, y float64)
Rotate(angle float64)
Shear(x, y float64)
ScaleAbout(sx, sy, x, y float64)
RotateAbout(angle, x, y float64)
ShearAbout(sx, sy, x, y float64)
TransformPoint(x, y float64) (tx, ty float64)
InvertY()
```

It is often desired to rotate or scale about a point that is not the origin. The functions `RotateAbout`, `ScaleAbout`, `ShearAbout` are provided as a convenience.

`InvertY` is provided in case Y should increase from bottom to top vs. the default top to bottom.

## Stack Functions

Save and restore the state of the context. These can be nested.

```go
Push()
Pop()
```

## Clipping Functions

Use clipping regions to restrict drawing operations to an area that you
defined using paths.

```go
Clip()
ClipPreserve()
ResetClip()
AsMask() *image.Alpha
SetMask(mask *image.Alpha)
InvertMask()
```

## Helper Functions

Sometimes you just don't want to write these yourself.

```go
Radians(degrees float64) float64
Degrees(radians float64) float64
LoadImage(path string) (image.Image, error)
LoadPNG(path string) (image.Image, error)
SavePNG(path string, im image.Image) error
```

![Separator](http://i.imgur.com/fsUvnPB.png)

## Another Example

See the output of this example below.

```go
package main

import "github.com/fogleman/gg"

func main() {
	const S = 1024
	dc := gg.NewContext(S, S)
	dc.SetRGBA(0, 0, 0, 0.1)
	for i := 0; i < 360; i += 15 {
		dc.Push()
		dc.RotateAbout(gg.Radians(float64(i)), S/2, S/2)
		dc.DrawEllipse(S/2, S/2, S*7/16, S/8)
		dc.Fill()
		dc.Pop()
	}
	dc.SavePNG("out.png")
}
```

![Ellipses](http://i.imgur.com/J9CBZef.png)

# GO IMAGE FILTERING TOOLKIT (GIFT)

[![GoDoc](https://godoc.org/github.com/disintegration/gift?status.svg)](https://godoc.org/github.com/disintegration/gift)
[![Build Status](https://travis-ci.org/disintegration/gift.svg?branch=master)](https://travis-ci.org/disintegration/gift)
[![Coverage Status](https://coveralls.io/repos/github/disintegration/gift/badge.svg?branch=master)](https://coveralls.io/github/disintegration/gift?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/disintegration/gift)](https://goreportcard.com/report/github.com/disintegration/gift)


*Package gift provides a set of useful image processing filters.*

Pure Go. No external dependencies outside of the Go standard library.


### INSTALLATION / UPDATING

    go get -u github.com/disintegration/gift


### DOCUMENTATION

http://godoc.org/github.com/disintegration/gift


### QUICK START

```go
// 1. Create a new filter list and add some filters.
g := gift.New(
	gift.Resize(800, 0, gift.LanczosResampling),
	gift.UnsharpMask(1, 1, 0),
)

// 2. Create a new image of the corresponding size.
// dst is a new target image, src is the original image.
dst := image.NewRGBA(g.Bounds(src.Bounds()))

// 3. Use the Draw func to apply the filters to src and store the result in dst.
g.Draw(dst, src)
```

### USAGE

To create a sequence of filters, the `New` function is used:
```go
g := gift.New(
	gift.Grayscale(),
	gift.Contrast(10),
)
```
Filters also can be added using the `Add` method:
```go
g.Add(GaussianBlur(2))
```

The `Bounds` method takes the bounds of the source image and returns appropriate bounds for the destination image to fit the result (for example, after using `Resize` or `Rotate` filters).

```go
dst := image.NewRGBA(g.Bounds(src.Bounds()))
```

There are two methods available to apply these filters to an image:

- `Draw` applies all the added filters to the src image and outputs the result to the dst image starting from the top-left corner (Min point).
```go
g.Draw(dst, src)
```

- `DrawAt` provides more control. It outputs the filtered src image to the dst image at the specified position using the specified image composition operator. This example is equivalent to the previous:
```go
g.DrawAt(dst, src, dst.Bounds().Min, gift.CopyOperator)
```

Two image composition operators are supported by now:
- `CopyOperator` - Replaces pixels of the dst image with pixels of the filtered src image. This mode is used by the Draw method.
- `OverOperator` - Places the filtered src image on top of the dst image. This mode makes sence if the filtered src image has transparent areas.

Empty filter list can be used to create a copy of an image or to paste one image to another. For example:
```go
// Create a new image with dimensions of the bgImage.
dstImage := image.NewRGBA(bgImage.Bounds())
// Copy the bgImage to the dstImage.
gift.New().Draw(dstImage, bgImage)
// Draw the fgImage over the dstImage at the (100, 100) position.
gift.New().DrawAt(dstImage, fgImage, image.Pt(100, 100), gift.OverOperator)
```


### SUPPORTED FILTERS

+ Transformations

    - Crop(rect image.Rectangle)
    - CropToSize(width, height int, anchor Anchor)
    - FlipHorizontal()
    - FlipVertical()
    - Resize(width, height int, resampling Resampling)
    - ResizeToFill(width, height int, resampling Resampling, anchor Anchor)
    - ResizeToFit(width, height int, resampling Resampling)
    - Rotate(angle float32, backgroundColor color.Color, interpolation Interpolation)
    - Rotate180()
    - Rotate270()
    - Rotate90()
    - Transpose()
    - Transverse()

+ Adjustments & effects

    - Brightness(percentage float32)
    - ColorBalance(percentageRed, percentageGreen, percentageBlue float32)
    - ColorFunc(fn func(r0, g0, b0, a0 float32) (r, g, b, a float32))
    - Colorize(hue, saturation, percentage float32)
    - ColorspaceLinearToSRGB()
    - ColorspaceSRGBToLinear()
    - Contrast(percentage float32)
    - Convolution(kernel []float32, normalize, alpha, abs bool, delta float32)
    - Gamma(gamma float32)
    - GaussianBlur(sigma float32)
    - Grayscale()
    - Hue(shift float32)
    - Invert()
    - Maximum(ksize int, disk bool)
    - Mean(ksize int, disk bool)
    - Median(ksize int, disk bool)
    - Minimum(ksize int, disk bool)
    - Pixelate(size int)
    - Saturation(percentage float32)
    - Sepia(percentage float32)
    - Sigmoid(midpoint, factor float32)
    - Sobel()
    - Threshold(percentage float32)
    - UnsharpMask(sigma, amount, threshold float32)


### FILTER EXAMPLES

The original image:

![](testdata/src.png)

Resulting images after applying some of the filters:

 name / result                              | name / result                              | name / result                              | name / result
--------------------------------------------|--------------------------------------------|--------------------------------------------|--------------------------------------------
resize                                      | crop_to_size                               | rotate_180                                 | rotate_30
![](testdata/dst_resize.png)                | ![](testdata/dst_crop_to_size.png)         | ![](testdata/dst_rotate_180.png)           | ![](testdata/dst_rotate_30.png)
brightness_increase                         | brightness_decrease                        | contrast_increase                          | contrast_decrease
![](testdata/dst_brightness_increase.png)   | ![](testdata/dst_brightness_decrease.png)  | ![](testdata/dst_contrast_increase.png)    | ![](testdata/dst_contrast_decrease.png)
saturation_increase                         | saturation_decrease                        | gamma_1.5                                  | gamma_0.5
![](testdata/dst_saturation_increase.png)   | ![](testdata/dst_saturation_decrease.png)  | ![](testdata/dst_gamma_1.5.png)            | ![](testdata/dst_gamma_0.5.png)
gaussian_blur                               | unsharp_mask                               | sigmoid                                    | pixelate
![](testdata/dst_gaussian_blur.png)         | ![](testdata/dst_unsharp_mask.png)         | ![](testdata/dst_sigmoid.png)              | ![](testdata/dst_pixelate.png)
colorize                                    | grayscale                                  | sepia                                      | invert
![](testdata/dst_colorize.png)              | ![](testdata/dst_grayscale.png)            | ![](testdata/dst_sepia.png)                | ![](testdata/dst_invert.png)
mean                                        | median                                     | minimum                                    | maximum
![](testdata/dst_mean.png)                  | ![](testdata/dst_median.png)               | ![](testdata/dst_minimum.png)              | ![](testdata/dst_maximum.png)
hue_rotate                                  | color_balance                              | color_func                                 | convolution_emboss
![](testdata/dst_hue_rotate.png)            | ![](testdata/dst_color_balance.png)        | ![](testdata/dst_color_func.png)           | ![](testdata/dst_convolution_emboss.png)

Here's the code that produces the above images:

```go
package main

import (
	"image"
	"image/color"
	"image/png"
	"log"
	"os"

	"github.com/disintegration/gift"
)

func main() {
	src := loadImage("testdata/src.png")

	filters := map[string]gift.Filter{
		"resize":               gift.Resize(100, 0, gift.LanczosResampling),
		"crop_to_size":         gift.CropToSize(100, 100, gift.LeftAnchor),
		"rotate_180":           gift.Rotate180(),
		"rotate_30":            gift.Rotate(30, color.Transparent, gift.CubicInterpolation),
		"brightness_increase":  gift.Brightness(30),
		"brightness_decrease":  gift.Brightness(-30),
		"contrast_increase":    gift.Contrast(30),
		"contrast_decrease":    gift.Contrast(-30),
		"saturation_increase":  gift.Saturation(50),
		"saturation_decrease":  gift.Saturation(-50),
		"gamma_1.5":            gift.Gamma(1.5),
		"gamma_0.5":            gift.Gamma(0.5),
		"gaussian_blur":        gift.GaussianBlur(1),
		"unsharp_mask":         gift.UnsharpMask(1, 1, 0),
		"sigmoid":              gift.Sigmoid(0.5, 7),
		"pixelate":             gift.Pixelate(5),
		"colorize":             gift.Colorize(240, 50, 100),
		"grayscale":            gift.Grayscale(),
		"sepia":                gift.Sepia(100),
		"invert":               gift.Invert(),
		"mean":                 gift.Mean(5, true),
		"median":               gift.Median(5, true),
		"minimum":              gift.Minimum(5, true),
		"maximum":              gift.Maximum(5, true),
		"hue_rotate":           gift.Hue(45),
		"color_balance":        gift.ColorBalance(10, -10, -10),
		"color_func": gift.ColorFunc(
			func(r0, g0, b0, a0 float32) (r, g, b, a float32) {
				r = 1 - r0   // invert the red channel
				g = g0 + 0.1 // shift the green channel by 0.1
				b = 0        // set the blue channel to 0
				a = a0       // preserve the alpha channel
				return r, g, b, a
			},
		),
		"convolution_emboss": gift.Convolution(
			[]float32{
				-1, -1, 0,
				-1, 1, 1,
				0, 1, 1,
			},
			false, false, false, 0.0,
		),
	}

	for name, filter := range filters {
		g := gift.New(filter)
		dst := image.NewNRGBA(g.Bounds(src.Bounds()))
		g.Draw(dst, src)
		saveImage("testdata/dst_"+name+".png", dst)
	}
}

func loadImage(filename string) image.Image {
	f, err := os.Open(filename)
	if err != nil {
		log.Fatalf("os.Open failed: %v", err)
	}
	defer f.Close()
	img, _, err := image.Decode(f)
	if err != nil {
		log.Fatalf("image.Decode failed: %v", err)
	}
	return img
}

func saveImage(filename string, img image.Image) {
	f, err := os.Create(filename)
	if err != nil {
		log.Fatalf("os.Create failed: %v", err)
	}
	defer f.Close()
	err = png.Encode(f, img)
	if err != nil {
		log.Fatalf("png.Encode failed: %v", err)
	}
}
```


gift

Efficient and robust glTF 2.0 reader, writer and validator.

# gltf [![PkgGoDev](https://pkg.go.dev/badge/github.com/qmuntal/gltf)](https://pkg.go.dev/github.com/qmuntal/gltf) [![Test](https://github.com/qmuntal/gltf/actions/workflows/test.yml/badge.svg)](https://github.com/qmuntal/gltf/actions/workflows/test.yml) [![Coverage Status](https://coveralls.io/repos/github/qmuntal/gltf/badge.svg?branch=master)](https://coveralls.io/github/qmuntal/gltf?branch=master) [![License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://opensource.org/licenses/BSD-2-Clause) [![Mentioned in Awesome Go](https://awesome.re/mentioned-badge-flat.svg)](https://github.com/avelino/awesome-go)

<div align="center">
 A Go module for efficient and robust serialization/deserialization of glTF 2.0, a royalty-free specification for the efficient transmission and loading of 3D scenes and models by applications, also known as "the JPEG of 3D".
 
 <a href="#star-main-features">Main Features</a> ❘
 <a href="#scroll-getting-started">Getting Started</a> ❘
 <a href="#raising_hand-contributing">Contributing</a> ❘
 <a href="#about-the-project">About The Project</a>
 
</div>

<img width="640" src="./assets/gopher_high.png" alt="Gopher glTF">

## :star: Main Features

- [gltf.Document](https://pkg.go.dev/github.com/qmuntal/gltf#Document): Idiomatic glTF data model
- [gltf.Open](https://pkg.go.dev/github.com/qmuntal/gltf#Open) / [gltf.Save](https://pkg.go.dev/github.com/qmuntal/gltf#Save): `.glTF` and `.glb` [d]encoding support
- [qmuntal/gltf/ext](https://pkg.go.dev/github.com/qmuntal/gltf/ext): Built-in extensability mechanism with principal extensions provided out of the box
- [qmuntal/gltf/modeler](https://pkg.go.dev/github.com/qmuntal/gltf/modeler): Friendly package to read and write accessors and buffer views
- [qmuntal/gltf/binary](https://pkg.go.dev/github.com/qmuntal/gltf/binary): Friendly and efficient package to read and write bytes from buffers

## :scroll: Getting started

### Data Model

`qmuntal/gltf` implements the whole glTF 2.0 specification. The top level element is the [gltf.Document](https://pkg.go.dev/github.com/qmuntal/gltf#Document) and it contains all the information to hold a gltf document in memory:

```go
// This document does not produce any valid glTF, it is just an example.
gltf.Document{
 Accessors: []*gltf.Accessor{
 {BufferView: gltf.Index(0), ComponentType: gltf.ComponentUshort, Type: gltf.AccessorScalar},
 },
 Asset: gltf.Asset{Version: "2.0", Generator: "qmuntal/gltf"},
 BufferViews: []*gltf.BufferView{
 {ByteLength: 72, ByteOffset: 0, Target: gltf.TargetElementArrayBuffer},
 },
 Buffers: []*gltf.Buffer{{ByteLength: 1033, URI: bufferData}},
 Meshes: []*gltf.Mesh{{
 Name: "Cube",
 }},
 Nodes: []*gltf.Node{{Name: "Cube", Mesh: gltf.Index(0)}},
 Scene: gltf.Index(0),
 Scenes: []*gltf.Scene{{Name: "Root Scene", Nodes: []int{0}}},
}
```

### Optional parameters

All optional properties whose default value does not match with the golang type zero value are defines as pointers. Take the following guidelines into account when working with optional values:

- It is safe to not define them when writing the glTF if the desired value is the default one.
- It is safe to expect that the optional values are not nil when reading a glTF.
- When assigning values to optional properties it may be helpful to use these utility functions:
 - `gltf.Index(1)`
 - `gltf.Float(0.5)`

### Reading a document

A [gltf.Document](https://pkg.go.dev/github.com/qmuntal/gltf#Document) can be decoded from any `io.Reader` by using [gltf.Decoder](https://pkg.go.dev/github.com/qmuntal/gltf#Decoder):

```go
resp, _ := http.Get("https://example.com/static/foo.gltf")
var doc gltf.Document
gltf.NewDecoder(resp.Body).Decode(&doc)
fmt.Print(doc.Asset)
```

When working with the file system it is more convenient to use [gltf.Open](https://pkg.go.dev/github.com/qmuntal/gltf#Open) as it automatically manages relative external buffers:

```go
doc, _ := gltf.Open("./foo.gltf")
fmt.Print(doc.Asset)
```

In both cases the decoder will automatically detect if the file is JSON/ASCII (gltf) or Binary (glb) based on its content.

### Writing a document

A [gltf.Document](https://pkg.go.dev/github.com/qmuntal/gltf#Document) can be encoded to any `io.Writer` by using [gltf.Encoder](https://pkg.go.dev/github.com/qmuntal/gltf#Encoder):

```go
var buf bytes.Buffer
gltf.NewEncoder(&buf).Encode(&doc)
http.Post("http://example.com/upload", "model/gltf+binary", &buf)
```

By default `gltf.NewEncoder` outputs a binary file, to generate a JSON/ASCII file set `AsBinary` to false:

```go
var buf bytes.Buffer
enc := gltf.NewEncoder(&buf)
enc.AsBinary = false
enc.Encode(&doc)
http.Post("http://example.com/upload", "model/gltf+json", &buf)
```

When working with the file system it is more convenient to use [gltf.Save](https://pkg.go.dev/github.com/qmuntal/gltf#Save) and [gltf.SaveBinary](https://pkg.go.dev/github.com/qmuntal/gltf#SaveBinary) as it automatically manages relative external buffers:

```go
gltf.Save(&doc, "./foo.gltf")
gltf.SaveBinary(&doc, "./foo.glb")
```

### Manipulating buffer views and accessors

The package [gltf/modeler](https://pkg.go.dev/github.com/qmuntal/gltf/modeler) defines a friendly API to read and write accessors and buffer views, abstracting away all the byte manipulation work and the idiosyncrasy of the glTF spec.

The following example creates a single colored triangle:

![screenshot](./assets/color-triangle.png)

```go
doc := gltf.NewDocument()
doc.Meshes = []*gltf.Mesh{{
 Name: "Pyramid",
 Primitives: []*gltf.Primitive{{
 Indices: gltf.Index(modeler.WriteIndices(doc, []uint16{0, 1, 2})),
 Attributes: gltf.PrimitiveAttributes{
 gltf.POSITION: modeler.WritePosition(doc, [][3]float32{{0, 0, 0}, {0, 10, 0}, {0, 0, 10}}),
 gltf.COLOR_0: modeler.WriteColor(doc, [][3]uint8{{255, 0, 0}, {0, 255, 0}, {0, 0, 255}}),
 },
 }},
}}
doc.Nodes = []*gltf.Node{{Name: "Pyramid", Mesh: gltf.Index(0)}}
doc.Scenes[0].Nodes = append(doc.Scenes[0].Nodes, 0)
gltf.Save(doc, "./test.gltf")
```

### Data interleaving

The data of the attributes that are stored in a single bufferView may be stored as an Array-Of-Structures, which may produce a rendering perfomance boost in static attributes. `qmuntal/gltf/modeler` facilitates the creation of interleaved accessors and buffer views with the methods [WritePrimitiveAttributes](https://pkg.go.dev/github.com/qmuntal/gltf/modeler#WritePrimitiveAttributes), [WriteAccessorsInterleaved](https://pkg.go.dev/github.com/qmuntal/gltf/modeler#WriteAccessorsInterleaved), and [WriteBufferViewInterleaved](https://pkg.go.dev/github.com/qmuntal/gltf/modeler#WriteBufferViewInterleaved) being the first one the most recommended for creating mesh primitives:

```go
doc := gltf.NewDocument()
attrs, _ := modeler.WritePrimitiveAttributes(doc,
 modeler.PrimitiveAttribute{Name: gltf.POSITION, Data: [][3]float32{{0, 0, 0}, {0, 10, 0}, {0, 0, 10}}},
 modeler.PrimitiveAttribute{Name: gltf.COLOR_0, Data: [][3]uint8{{255, 0, 0}, {0, 255, 0}, {0, 0, 255}}},
)
doc.Meshes = []*gltf.Mesh{{
 Name: "Pyramid",
 Primitives: []*gltf.Primitive{{
 Indices: gltf.Index(modeler.WriteIndices(doc, []uint16{0, 1, 2})),
 Attributes: attrs,
 }},
}}
doc.Nodes = []*gltf.Node{{Name: "Pyramid", Mesh: gltf.Index(0)}}
doc.Scenes[0].Nodes = append(doc.Scenes[0].Nodes, 0)
gltf.Save(doc, "./test.gltf")
```

### Manipulating bytes

The package [gltf/binary](https://pkg.go.dev/github.com/qmuntal/gltf/binary) defines a friendly and efficient API to read and write bytes from buffers, abstracting away all the byte manipulation work. This package is very low level and normal users should use `gltf/modeler` instead as it provides another level of abstraction that understands how bytes are associated to other entities.

This package is very similary to the Go `binary` package, the main differences are that it is highly specialized in glTF data types and that it only have to deal with little endian encoding.

### Dealing with extensions

`qmuntal/gltf` is designed to support dynamic extensions. By default only the core specification is decoded and the data inside the extensions objects are stored as `json.RawMessage` so they can be decoded by the caller or automatically encoded when saving the document.

Some of the official extensions are implemented under [ext](ext/).

To decode one of the supported extensions the only required action is to import the associated package, this way the extension will not be stored as `json.RawMessage` but as the type defined in the extension package:

```go
import (
 "github.com/qmuntal/gltf"
 "github.com/qmuntal/gltf/ext/lightspunctual"
)

func main() {
 doc, _ := gltf.Open("./foo.gltf")
 if v, ok := doc.Extensions[lightspunctual.ExtensionName]; ok {
 for _, l := range v.(lightspunctual.Lights) {
 fmt.Print(l.Type)
 }
 }
}
```

It is not necessary to call `gltf.RegisterExtension` for built-in extensions, as these auto-register themselves when the package is initialized.

#### External extension

This list is the list of known extensions implemented in other modules:

- [draco-go/gltf/draco](https://github.com/qmuntal/draco-go)

#### Custom extensions

To implement a custom extension encoding, provide a `struct` that can be encoded as a JSON object as dictated by the spec.

To implement a custom extension decoding, call [gltf.RegisterExtension](https://pkg.go.dev/github.com/qmuntal/gltf#RegisterExtension) at least once before decoding, providing the identifier of the extension and a function that decodes the JSON bytes to the desired `struct`:

```go
const ExtensionName = "FAKE_Extension"

type Foo struct {
 BufferView int `json:"bufferView"`
 Attributes gltf.Attributes `json:"attributes"`
}

func init() {
 gltf.RegisterExtension(ExtensionName, Unmarshal)
}

func Unmarshal(data []byte) (any, error) {
 foo := new(Foo)
 err := json.Unmarshal(data, foo)
 return foo, err
}
```

## :raising_hand: Contributing

PRs, issues, and feedback from ninja gophers are very welcomed.

## About The Project

This library is a complete implementation of glTF 2.0, and its explicit aim is to provide a production-ready, idiomatic and curated API to perform any kind of glTF manipulation.

It is out of the scope to implement convertes to/from other file formats and to provide mechanisms to create and manipulate 3D geometry.

The current API is still not frozen and can suffer minor changes until it reached v1.0.

Please use the issue tracker or the if you'd like to report problems or discuss features.

gltf

Port of webcolors library from Python to Go.

### go-webcolors

A library for working with color names and color value formats defined by the HTML and CSS specifications for use in documents on the Web.

go-webcolors is available on the [Godoc]

This library is originally available in Python by James Bennett, [PyPI] and [Bitbucket]. go-webcolors have been ported from Python to Go with all the functions available. Contributions in the form of patches, issue reports, bug reports and pull requests are welcome. 

Support is included for the following formats:

- Specification-defined color names
- Six-digit hexadecimal
- Three-digit hexadecimal
- Integer rgb triplet
- Percentage rgb triplet

[PyPI]: https://pypi.python.org/pypi/webcolors/1.4
[Bitbucket]: http://www.bitbucket.org/ubernostrum/webcolors/overview/
[Godoc]: http://godoc.org/github.com/jyotiska/go-webcolors


go-webcolors

Collection of image processing algorithms in pure Go.

# bild

![bild logo](assets/img/logo.png)  

[![MIT License](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](https://github.com/anthonynsimon/bild/blob/master/LICENSE)
[![GoDoc](https://godoc.org/github.com/anthonynsimon/bild?status.svg)](https://godoc.org/github.com/anthonynsimon/bild)
[![Go Report Card](https://goreportcard.com/badge/github.com/anthonynsimon/bild)](https://goreportcard.com/report/github.com/anthonynsimon/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](https://pkg.go.dev/mod/github.com/anthonynsimon/bild?tab=packages).


## 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](https://github.com/anthonynsimon/bild/releases)


```
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.

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

## Basic package usage example:
```go
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)

![example](assets/img/brightness.jpg)  

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

![example](assets/img/contrast.jpg)  

### Gamma
    result := adjust.Gamma(img, 2.2)

![example](assets/img/gamma.jpg)  


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

![example](assets/img/hue.jpg)  

### Saturation
    result := adjust.Saturation(img, 0.5)

![example](assets/img/saturation.jpg)  



## Blend modes
    import "github.com/anthonynsimon/bild/blend"

    result := blend.Multiply(bg, fg)

| Add | Color Burn | Color Dodge |
| :----------: | :---------: | :------: |
| ![](assets/img/add.jpg) | ![](assets/img/colorburn.jpg) | ![](assets/img/colordodge.jpg) |
| **Darken** | **Difference** | **Divide** |
| ![](assets/img/darken.jpg) | ![](assets/img/difference.jpg) | ![](assets/img/divide.jpg) |
| **Exclusion** | **Lighten** | **Linear Burn** |
| ![](assets/img/exclusion.jpg) | ![](assets/img/lighten.jpg) | ![](assets/img/linearburn.jpg) |
| **Linear Light** | **Multiply** | **Normal** |
| ![](assets/img/linearlight.jpg) | ![](assets/img/multiply.jpg) | ![](assets/img/normal.jpg) |
| **Opacity** | **Overlay** | **Screen** |
| ![](assets/img/opacity.jpg) | ![](assets/img/overlay.jpg) | ![](assets/img/screen.jpg) |
| **Soft Light** | **Subtract** | |
| ![](assets/img/softlight.jpg) | ![](assets/img/subtract.jpg) | |


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

### Box Blur
    result := blur.Box(img, 3.0)

![example](assets/img/boxblur.jpg)  


### Gaussian Blur
    result := blur.Gaussian(img, 3.0)


![example](assets/img/gaussianblur.jpg)  


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

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

![example](assets/img/extractchannel.jpg)

### Extract Multiple Channels
    result := channel.ExtractMultiple(img, channel.Red, channel.Alpha)

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

### Dilate
    result := effect.Dilate(img, 3)

![example](assets/img/dilate.jpg)     

### Edge Detection
    result := effect.EdgeDetection(img, 1.0)

![example](assets/img/edgedetection.jpg)  

### Emboss
    result := effect.Emboss(img)

![example](assets/img/emboss.jpg)  

### Erode
    result := effect.Erode(img, 3)

![example](assets/img/erode.jpg)   

### Grayscale
    result := effect.Grayscale(img)

![example](assets/img/grayscale.jpg)  

### Invert
    result := effect.Invert(img)

![example](assets/img/invert.jpg)  

### Median
    result := effect.Median(img, 10.0)

![example](assets/img/median.jpg)  

### Sepia
    result := effect.Sepia(img)

![example](assets/img/sepia.jpg)  

### Sharpen
    result := effect.Sharpen(img)

![example](assets/img/sharpen.jpg)  

### Sobel
    result := effect.Sobel(img)

![example](assets/img/sobel.jpg)  

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

![example](assets/img/unsharpmask.jpg)  


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

### RGBA Histogram
    hist := histogram.NewRGBAHistogram(img)
    result := hist.Image()

![example](assets/img/histogram.png)  


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

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

![example](assets/img/noiseuniform.jpg)  


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

![example](assets/img/noisebinary.jpg)  


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

![example](assets/img/noisegaussian.jpg)  

### Perlin Noise 
    result := noise.GeneratePerlin(280, 280, 0.25)
![example](assets/img/perlin.jpg)  

## 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)

![example](assets/img/floodfill.jpg) 


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

### Threshold
    result := segment.Threshold(img, 128)

![example](assets/img/threshold.jpg)


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

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

![example](assets/img/crop.jpg)

### FlipH
    result := transform.FlipH(img)

![example](assets/img/fliph.jpg)  

### FlipV
    result := transform.FlipV(img)

![example](assets/img/flipv.jpg) 


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

| Nearest Neighbor | Linear | Gaussian |
|:----------: | :---------: | :------: |
| ![](assets/img/resizenearestneighbor.jpg) | ![](assets/img/resizelinear.jpg) | ![](assets/img/resizegaussian.jpg) |
| **Mitchell Netravali** | **Catmull Rom** | **Lanczos** |
| ![](assets/img/resizemitchell.jpg) | ![](assets/img/resizecatmullrom.jpg) | ![](assets/img/resizelanczos.jpg) |


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

![example](assets/img/rotation03.gif)

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

![example](assets/img/rotation01.gif)

    // 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}})

![example](assets/img/rotation02.gif)

### Shear Horizontal
    result := transform.ShearH(img, 30)

![example](assets/img/shearh.jpg)  

### Shear Vertical
    result := transform.ShearV(img, 30)

![example](assets/img/shearv.jpg) 

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

![example](assets/img/translate.jpg) 


## 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](CHANGELOG.md) for more details.

## License

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


bild

Small package for fast and efficient image processing using libvips.

bimg

Dominant color extractor with no external dependencies.

Simple image color extractor written in Go with no external dependencies.

[![Go Reference](https://pkg.go.dev/badge/github.com/marekm4/color-extractor.svg)](https://pkg.go.dev/github.com/marekm4/color-extractor)
[![Go Report Card](https://goreportcard.com/badge/github.com/marekm4/color-extractor)](https://goreportcard.com/report/github.com/marekm4/color-extractor)
[![Go Coverage](https://github.com/marekm4/color-extractor/wiki/coverage.svg)](https://raw.githack.com/wiki/marekm4/color-extractor/coverage.html)

Demo:

https://color-extractor-demo.marekm4.com/

Blog post:

https://medium.com/@marek.michalik/c-vs-rust-vs-go-performance-analysis-945ab749056c

Usage:
```go
package main

import (
	"fmt"
	"image"
	_ "image/jpeg"
	"os"

	"github.com/marekm4/color-extractor"
)

func main() {
	file := "Fotolia_45549559_320_480.jpg"
	imageFile, _ := os.Open(file)
	defer imageFile.Close()

	image, _, _ := image.Decode(imageFile)
	colors := color_extractor.ExtractColors(image)

	fmt.Println(colors)
}
```

Example image:

![Image](https://raw.githubusercontent.com/marekm4/color-extractor/master/example/Fotolia_45549559_320_480.jpg)

Extracted colors:

![Colors](https://raw.githubusercontent.com/marekm4/color-extractor/master/example/colors.png)


color-extractor

Library for encode and decode webp pictures, using libwebp.

![logo](test_data/images/logo.jpg)
# go-webp
[![Build Status](https://api.travis-ci.com/kolesa-team/go-webp.svg?branch=master)](https://travis-ci.com/github/kolesa-team/go-webp)
[![GoDoc](https://godoc.org/github.com/kolesa-team/go-webp?status.svg)](https://godoc.org/github.com/kolesa-team/go-webp)
[![Go Report](https://goreportcard.com/badge/github.com/kolesa-team/go-webp)](https://goreportcard.com/report/github.com/kolesa-team/go-webp)
[![codecov](https://codecov.io/gh/kolesa-team/go-webp/branch/master/graph/badge.svg)](https://codecov.io/gh/kolesa-team/go-webp)

Golang Webp library for encoding and decoding, using **C** binding for Google libwebp

## Requirements
[libwebp](https://developers.google.com/speed/webp/docs/api)

## Benchmarks
```text
% go test -bench "^BenchmarkDecode" ./webp                                                                                
goos: darwin
goarch: amd64
pkg: github.com/kolesa-team/go-webp/webp
BenchmarkDecodeLossy-12                       45          25965139 ns/op
BenchmarkDecodeXImageLossy-12                 13          90735879 ns/op
BenchmarkDecodeLossless-12                    64          18887482 ns/op
BenchmarkDecodeXImageLossless-12              27          42422596 ns/op
PASS
ok      github.com/kolesa-team/go-webp/webp     7.877s
```

## Install libwebp
#### MacOS:
```bash
brew install webp
```
#### Linux:
```bash
sudo apt-get update
sudo apt-get install libwebp-dev
```

## Install
`go get -u github.com/kolesa-team/go-webp`

## Examples

#### Decode:
```go
package main

import (
	"image/jpeg"
	"log"
	"os"

	"github.com/kolesa-team/go-webp/decoder"
	"github.com/kolesa-team/go-webp/webp"
)

func main() {
	file, err := os.Open("test_data/images/m4_q75.webp")
	if err != nil {
		log.Fatalln(err)
	}

	output, err := os.Create("example/output_decode.jpg")
	if err != nil {
		log.Fatal(err)
	}
	defer output.Close()

	img, err := webp.Decode(file, &decoder.Options{})
	if err != nil {
		log.Fatalln(err)
	}

	if err = jpeg.Encode(output, img, &jpeg.Options{Quality:75}); err != nil {
		log.Fatalln(err)
	}
}
```

```bash
go run example/decode/main.go
```

#### Encode
```go
package main

import (
	"github.com/kolesa-team/go-webp/encoder"
	"github.com/kolesa-team/go-webp/webp"
	"image/jpeg"
	"log"
	"os"
)

func main() {
	file, err := os.Open("test_data/images/source.jpg")
	if err != nil {
		log.Fatalln(err)
	}

	img, err := jpeg.Decode(file)
	if err != nil {
		log.Fatalln(err)
	}

	output, err := os.Create("example/output_decode.webp")
	if err != nil {
		log.Fatal(err)
	}
	defer output.Close()

	options, err := encoder.NewLossyEncoderOptions(encoder.PresetDefault, 75)
	if err != nil {
		log.Fatalln(err)
	}

	if err := webp.Encode(output, img, options); err != nil {
		log.Fatalln(err)
	}
}
```
```bash
go run example/encode/main.go
```

## TODO
- return aux stats
- container api
- incremental decoding

## License
MIT licensed. See the LICENSE file for details.



go-webp

Go package for computer vision using OpenCV 3.3+.

gocv

![GitHub Action](https://github.com/corona10/goimagehash/workflows/goimagehash%20workflow/badge.svg)
[![GoDoc](https://godoc.org/github.com/corona10/goimagehash?status.svg)](https://godoc.org/github.com/corona10/goimagehash)
[![Go Report Card](https://goreportcard.com/badge/github.com/corona10/goimagehash)](https://goreportcard.com/report/github.com/corona10/goimagehash)

# goimagehash
> Inspired by [imagehash](https://github.com/JohannesBuchner/imagehash)

A image hashing library written in Go. ImageHash supports:
* [Average hashing](http://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html)
* [Difference hashing](http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html)
* [Perception hashing](http://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html)
* [Wavelet hashing](https://fullstackml.com/wavelet-image-hash-in-python-3504fdd282b5) [TODO]

## Installation
```
go get github.com/corona10/goimagehash
```
## Special thanks to
* [Haeun Kim](https://github.com/haeungun/)

## Usage

``` Go
func main() {
        file1, _ := os.Open("sample1.jpg")
        file2, _ := os.Open("sample2.jpg")
        defer file1.Close()
        defer file2.Close()

        img1, _ := jpeg.Decode(file1)
        img2, _ := jpeg.Decode(file2)
        hash1, _ := goimagehash.AverageHash(img1)
        hash2, _ := goimagehash.AverageHash(img2)
        distance, _ := hash1.Distance(hash2)
        fmt.Printf("Distance between images: %v\n", distance)

        hash1, _ = goimagehash.DifferenceHash(img1)
        hash2, _ = goimagehash.DifferenceHash(img2)
        distance, _ = hash1.Distance(hash2)
        fmt.Printf("Distance between images: %v\n", distance)
        width, height := 8, 8
        hash3, _ := goimagehash.ExtAverageHash(img1, width, height)
        hash4, _ := goimagehash.ExtAverageHash(img2, width, height)
        distance, _ = hash3.Distance(hash4)
        fmt.Printf("Distance between images: %v\n", distance)
        fmt.Printf("hash3 bit size: %v\n", hash3.Bits())
        fmt.Printf("hash4 bit size: %v\n", hash4.Bits())

        var b bytes.Buffer
        foo := bufio.NewWriter(&b)
        _ = hash4.Dump(foo)
        foo.Flush()
        bar := bufio.NewReader(&b)
        hash5, _ := goimagehash.LoadExtImageHash(bar)
}
```

## Release Note
### v1.1.0
- The performance of Perceptionhash is enhanced.

### v1.0.3
- Add workflow for GithubAction
- Fix typo on the GoDoc for LoadImageHash

### v1.0.2
- go.mod is now used for install goimagehash

### v1.0.1
- Perception/ExtPerception hash creation times are reduced

### v1.0.0
**IMPORTANT**
goimagehash v1.0.0 does not have compatible with the before version for future features

- More flexible extended hash APIs are provided ([ExtAverageHash](https://godoc.org/github.com/corona10/goimagehash#ExtAverageHash), [ExtPerceptionHash](https://godoc.org/github.com/corona10/goimagehash#ExtPerceptionHash), [ExtDifferenceHash](https://godoc.org/github.com/corona10/goimagehash#ExtDifferenceHash))
- New serialization APIs are provided([ImageHash.Dump](https://godoc.org/github.com/corona10/goimagehash#ImageHash.Dump), [ExtImageHash.Dump](https://godoc.org/github.com/corona10/goimagehash#ExtImageHash.Dump))
- [ExtImageHashFromString](https://godoc.org/github.com/corona10/goimagehash#ExtImageHashFromString), [ImageHashFromString](https://godoc.org/github.com/corona10/goimagehash#ImageHashFromString) is deprecated and will be removed
- New deserialization APIs are provided([LoadImageHash](https://godoc.org/github.com/corona10/goimagehash#LoadImageHash), [LoadExtImageHash](https://godoc.org/github.com/corona10/goimagehash#LoadExtImageHash))
- Bits APIs are provided to measure actual bit size of hash

### v0.3.0
- Support DifferenceHashExtend.
- Support AverageHashExtend.
- Support PerceptionHashExtend by @TokyoWolFrog.

### v0.2.0
- Perception Hash is updated.
- Fix a critical bug of finding median value.

### v0.1.0
- Support Average hashing
- Support Difference hashing
- Support Perception hashing
- Use bits.OnesCount64 for computing Hamming distance by @dominikh
- Support hex serialization methods to ImageHash by @brunoro


goimagehash

The imghdr module determines the type of image contained in a file for Go.

[![Build Status](https://travis-ci.org/corona10/goimghdr.svg?branch=master)](https://travis-ci.org/corona10/goimghdr)
[![GoDoc](https://godoc.org/github.com/corona10/goimghdr?status.svg)](https://godoc.org/github.com/corona10/goimghdr)
[![Go Report Card](https://goreportcard.com/badge/github.com/corona10/goimghdr)](https://goreportcard.com/report/github.com/corona10/goimghdr)
[![Coverage Status](https://coveralls.io/repos/github/corona10/goimghdr/badge.svg?branch=coverall)](https://coveralls.io/github/corona10/goimghdr?branch=coverall)

# goimghdr
> Inspired by Python's [imghdr](https://docs.python.org/3/library/imghdr.html)

## Installation
```
go get github.com/corona10/goimghdr
```

## List of return value

| Value  | Image format                      |
|--------|-----------------------------------|
| "rgb"  | SGI ImgLib Files                  |
| "gif"  | GIF 87a and 89a Files             |
| "pbm"  | Portable Bitmap Files             |
| "pgm"  | Portable Graymap Files            |
| "ppm"  | Portable Pixmap Files             |
| "tiff" | TIFF Files                        |
| "rast" | Sun Raster Files                  |
| "xbm"  | X Bitmap Files                    |
| "jpeg" | JPEG data in JFIF or Exif formats |
| "bmp"  | BMP files                         |
| "png"  | Portable Network Graphics         |
| "webp" | WebP files                        |
| "exr"  | OpenEXR Files                     |

## Usage

[example](examples/example.go)

[![asciicast](https://asciinema.org/a/zfh9TERizU7RcSAxXo9ioKQq4.png)](https://asciinema.org/a/zfh9TERizU7RcSAxXo9ioKQq4)

## Special thanks to
* [Haeun Kim](https://github.com/haeungun/)

## Reference
* [CPython imghdr module](https://docs.python.org/3/library/imghdr.html)
* [DSCN0029.jpg](imgData/DSCN0029.jpg) is from [ianare/exif-samples](https://github.com/ianare/exif-samples)


goimghdr

Library and CMD tool for generating funny avatars.

# GOvatar
[![License](http://img.shields.io/:license-mit-blue.svg)](LICENSE)
[![GoDoc](https://godoc.org/github.com/o1egl/govatar?status.svg)](https://godoc.org/github.com/o1egl/govatar)
[![Build](https://github.com/o1egl/govatar/actions/workflows/main.yaml/badge.svg)](https://github.com/o1egl/govatar/actions/workflows/main.yaml)
[![Coverage](https://codecov.io/gh/o1egl/govatar/branch/master/graph/badge.svg)](https://codecov.io/gh/o1egl/govatar)
[![Go Report Card](https://goreportcard.com/badge/github.com/o1egl/govatar)](https://goreportcard.com/report/github.com/o1egl/govatar)

![GOvatar image](files/avatars.jpg)

GOvatar is an avatar generation library written in GO

---

#### Notes
1. From release v0.4.0 onward, the minimal supported golang version is 1.16.

---

## Install

### Brew

```
$ brew tap o1egl/tap
$ brew install govatar
```

### Docker

```
$ docker pull o1egl/govatar
```

### From source

```
$ go get -u github.com/o1egl/govatar/...
```

Prebuilt [binary packages](https://github.com/o1egl/govatar/releases) are available for Mac, Linux, and Windows.

## Usage

```bash
$ govatar generate male -o avatar.png                        # Generates random avatar.png for male
$ govatar generate female -o avatar.png                      # Generates random avatar.png for female
$ govatar generate male -u username@site.com -o avatar.png   # Generates avatar.png for specified username
$ govatar -h                                                 # Display help message
```

#### As lib

Generates avatar and save it to filePath

```go
err := govatar.GenerateFile(govatar.MALE, "/path/to/avatar.jpg")
err := govatar.GenerateFileForUsername(govatar.MALE, "username", "/path/to/avatar.jpg")
````

Generates an avatar and returns it as an image.Image

```go
img, err := govatar.Generate(govatar.MALE)
img, err := govatar.GenerateForUsername(govatar.MALE, "username")
````


## Copyright, License & Contributors

### Adding new skins

1. Add new skins to the background, male/clothes, female/hair, etc...
2. Submit pull request :)

### Submitting a Pull Request

1. Fork it.
2. Create a branch (`git checkout -b my_branch`)
3. Commit your changes (`git commit -am "Added new awesome avatars"`)
4. Push to the branch (`git push origin my_branch`)
5. Open a [Pull Request](https://github.com/o1egl/govatar/pulls)
6. Enjoy a refreshing Diet Coke and wait

GOvatar is released under the MIT license. See [LICENSE](LICENSE)


govatar

A lightning fast image processing and resizing library for Go.

govips

# `ln` The 3D Line Art Engine

`ln` is a vector-based 3D renderer written in Go. It is used to produce 2D
vector graphics (think SVGs) depicting 3D scenes.

*The output of an OpenGL pipeline is a rastered image. The output of `ln` is
a set of 2D vector paths.*

![Examples](http://i.imgur.com/HY2Fg2t.png)

## Motivation

I created this so I could plot 3D drawings with my
[Makeblock XY Plotter](http://www.makeblock.cc/xy-plotter-robot-kit/).

Here's one of my drawings from the plotter...

![Example](http://i.imgur.com/NbgpUhQ.jpg)

## Installation

	go get github.com/fogleman/ln/ln

## Features

- Primitives
	- Sphere
	- Cube
	- Triangle
	- Cylinder
	- 3D Functions
- Triangle Meshes
	- OBJ & STL
- Vector-based "Texturing"
- CSG (Constructive Solid Geometry) Operations
	- Intersection
	- Difference
	- Union
- Output to PNG or SVG

## How it Works

To understand how `ln` works, it's useful to start with the `Shape` interface:

```go
type Shape interface {
	Paths() Paths
	Intersect(Ray) Hit
	Contains(Vector, float64) bool
	BoundingBox() Box
	Compile()
}
```

Each shape must provide some `Paths` which are 3D polylines on the surface
of the solid. Ultimately anything drawn in the final image is based on these
paths. These paths can be anything. For a sphere they could be lat/lng grid
lines, a triangulated-looking surface, dots on the surface, etc. This is what
we call vector-based texturing. Each built-in `Shape` ships with a default
`Paths` function (e.g. a `Cube` simply draws the outline of a cube) but you
can easily provide your own.

Each shape must also provide an `Intersect` method that lets the engine test
for ray-solid intersection. This is how the engine knows what is visible to the
camera and what is hidden.

All of the `Paths` are chopped up to some granularity and each point is tested
by shooting a ray toward the camera. If there is no intersection, that point is
visible. If there is an intersection, it is hidden and will not be rendered.

The visible points are then transformed into 2D space using transformation
matrices. The result can then be rendered as PNG or SVG.

The `Contains` method is only needed for CSG (Constructive Solid Geometry)
operations.

## Hello World: A Single Cube

### The Code

```go
package main

import "github.com/fogleman/ln/ln"

func main() {
	// create a scene and add a single cube
	scene := ln.Scene{}
	scene.Add(ln.NewCube(ln.Vector{-1, -1, -1}, ln.Vector{1, 1, 1}))

	// define camera parameters
	eye := ln.Vector{4, 3, 2} // camera position
	center := ln.Vector{0, 0, 0} // camera looks at
	up := ln.Vector{0, 0, 1} // up direction

	// define rendering parameters
	width := 1024.0 // rendered width
	height := 1024.0 // rendered height
	fovy := 50.0 // vertical field of view, degrees
	znear := 0.1 // near z plane
	zfar := 10.0 // far z plane
	step := 0.01 // how finely to chop the paths for visibility testing

	// compute 2D paths that depict the 3D scene
	paths := scene.Render(eye, center, up, width, height, fovy, znear, zfar, step)

	// render the paths in an image
	paths.WriteToPNG("out.png", width, height)

	// save the paths as an svg
	paths.WriteToSVG("out.svg", width, height)
}
```

### The Output

![Cube](http://i.imgur.com/d2dGrOJ.png)

## Custom Texturing

Suppose we want to draw cubes with vertical stripes on their sides, as
shown in the skyscrapers example above. We can just define a new type
and override the `Paths()` function.

```go
type StripedCube struct {
	ln.Cube
	Stripes int
}

func (c *StripedCube) Paths() ln.Paths {
	var paths ln.Paths
	x1, y1, z1 := c.Min.X, c.Min.Y, c.Min.Z
	x2, y2, z2 := c.Max.X, c.Max.Y, c.Max.Z
	for i := 0; i <= c.Stripes; i++ {
		p := float64(i) / float64(c.Stripes)
		x := x1 + (x2-x1)*p
		y := y1 + (y2-y1)*p
		paths = append(paths, ln.Path{{x, y1, z1}, {x, y1, z2}})
		paths = append(paths, ln.Path{{x, y2, z1}, {x, y2, z2}})
		paths = append(paths, ln.Path{{x1, y, z1}, {x1, y, z2}})
		paths = append(paths, ln.Path{{x2, y, z1}, {x2, y, z2}})
	}
	return paths
}
```

Now `StripedCube` instances can be added to the scene.

## Constructive Solid Geometry (CSG)

You can easily construct complex solids using Intersection, Difference, Union.

```go
shape := ln.NewDifference(
	ln.NewIntersection(
		ln.NewSphere(ln.Vector{}, 1),
		ln.NewCube(ln.Vector{-0.8, -0.8, -0.8}, ln.Vector{0.8, 0.8, 0.8}),
	),
	ln.NewCylinder(0.4, -2, 2),
	ln.NewTransformedShape(ln.NewCylinder(0.4, -2, 2), ln.Rotate(ln.Vector{1, 0, 0}, ln.Radians(90))),
	ln.NewTransformedShape(ln.NewCylinder(0.4, -2, 2), ln.Rotate(ln.Vector{0, 1, 0}, ln.Radians(90))),
)
```

This is `(Sphere & Cube) - (Cylinder | Cylinder | Cylinder)`.

Unfortunately, it's difficult to compute the joint formed at the boundaries of these combined shapes, so sufficient texturing is needed on the original solids for a decent result.

![Example](http://i.imgur.com/gk8UtVK.gif)

Tool & Go library for image manipulation (Merge, Crop, Resize, Watermark, Animate).

![Mergi](./logo/logo.png)


 <img src="https://img.shields.io/badge/imaging-4%20terminal%20lovers-00afef.svg?longCache=true&style=for-the-badge"/>


Result | Terminal Code
-----------------------------------|------------------------------------------
![Intro](https://i.imgur.com/UmbQ5CJ.gif) | `mergi -t TT -i https://raw.githubusercontent.com/ashleymcnamara/gophers/master/Facepalm_Gopher.png -r "131 131" -i https://raw.githubusercontent.com/ashleymcnamara/gophers/master/Facepalm_Picard_Gopher.png -r "131 131" -a "sprite 50"`

[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/noelyahan/mergi)
[![Build Status](https://travis-ci.com/noelyahan/mergi.svg?branch=master)](https://travis-ci.com/noelyahan/mergi)
[![codecov](https://codecov.io/gh/noelyahan/mergi/branch/master/graph/badge.svg)](https://codecov.io/gh/noelyahan/mergi)
[![Go Report Card](https://goreportcard.com/badge/github.com/noelyahan/mergi)](https://goreportcard.com/report/github.com/noelyahan/mergi)
[![Teligram Chat](https://img.shields.io/badge/telegram-join%20chat-blue.svg)](https://t.me/joinchat/IzEQ3xEXCiRCh8L2q6pTLg)

## :tada: Basic Overview

Image manipulation [go library](http://godoc.org/github.com/noelyahan/mergi) plus [cross platform CLI tool](https://github.com/noelyahan/mergi/tree/master/cmd/mergi).

## ⚡ Features

- 🛠 Merge
- ✂️ Crop
- 💣 Resize
- 🖃 Watermark
- 💖 Animate
- 🔥 Easing
- 🦎 Transition

 

## 🚀 Getting started

### Install via `go get`

To install Mergi, use `go get`, or download the binary file from [Releases](https://github.com/noelyahan/mergi/releases) page.

```bash
$ go get github.com/noelyahan/mergi
```

Usage:

```
 ╔╦╗╔═╗╦═╗╔═╗╦
 ║║║║╣ ╠╦╝║ ╦║
 ╩ ╩╚═╝╩╚═╚═╝╩
 let's go & make imaging fun
 http://mergi.io
 version 1.0.0

 -a string
 	Enter animation type=[sprite, slide] and the delay to get mergi gif animation ex: smooth 10
 -c value
 	Enter crop points and height and width ex: x y w h
 -f string
 	Enter true if you want to process the final output
 -i value
 	Enter images that want to merge ex: /path/img1 or url
 -o string
 	Enter image outputs file ex: out.png or out.jpg (default "out.png")
 -r value
 	Enter resize width and height of the output ex: 100 200
 -t string
 	Enter a merge template string ex: TBTBTB (default "T")
 -w value
 	Enter watermark image and points to place it, [-r w h] is optional ex: /path/img -r w h x y

```
 

#### 🛠 Merge

Image 1 | Image 2 | Result Image
-----------------------------------|-------------------------------------------|------------------------------------------
![dstImage](testdata/mergi_bg_1.png)|![srcImage](testdata/mergi_bg_2.png) | ![dstImage](testdata/doc/merge_tt.png)
![dstImage](testdata/mergi_bg_1.png)|![srcImage](testdata/mergi_bg_2.png) | ![dstImage](testdata/doc/merge_tb.png)

##### `Mergi Tool`
###### Horizontal 
```bash
mergi \
-t TT \
-i testdata/mergi_bg_1.png \
-i testdata/mergi_bg_2.png
```

###### Vertical 
```bash
mergi \
-t TB \
-i testdata/mergi_bg_1.png \
-i testdata/mergi_bg_2.png
```
##### `Mergi Library`
```go
image1, _ := mergi.Import(impexp.NewFileImporter("./testdata/mergi_bg_1.png"))
image2, _ := mergi.Import(impexp.NewFileImporter("./testdata/mergi_bg_2.png"))

horizontalImage, _ := mergi.Merge("TT", []image.Image{image1, image2})
mergi.Export(impexp.NewFileExporter(horizontalImage, "horizontal.png"))

verticalImage, _ := mergi.Merge("TB", []image.Image{image1, image2})
mergi.Export(impexp.NewFileExporter(verticalImage, "vertical.png"))
```


 

#### ✂️ Crop
Image | Result Image
-----------------------------------|------------------------------------------
![srcImage](testdata/mergi_bg_1.png) | ![dstImage](testdata/doc/crop.png)

##### `Mergi Tool`
```bash
mergi \
-i testdata/mergi_bg_1.png \
-c "10 40 200 110"
```

##### `Mergi Library`
```go
img, _ := mergi.Import(impexp.NewFileImporter("./testdata/mergi_bg_1.png"))
res, _ := mergi.Crop(img, image.Pt(10, 40), image.Pt(200, 110))
mergi.Export(impexp.NewFileExporter(res, "crop.png"))
```

 

#### 💣 Resize
Image | Result Image
-----------------------------------|-------------------------------------------
![srcImage](testdata/mergi_bg_1.png) | ![dstImage](testdata/doc/resize.png)

##### `Mergi Tool`
```bash
mergi \
-i testdata/mergi_bg_1.png \
-r "180 80"
```

##### `Mergi Library`
```go
img, _ := mergi.Import(impexp.NewFileImporter("./testdata/mergi_bg_1.png"))
res, _ := mergi.Resize(img, uint(180), uint(80))
mergi.Export(impexp.NewFileExporter(res, "resize.png"))
```

 

#### 🖃 Watermark
Image | Watermark Image | Result Image
-----------------------------------|-------------------------------------------|------------------------------------------
![srcImage](testdata/mergi_bg_1.png) | ![dstImage](testdata/mergi_logo_watermark_90x40.png) | ![dstImage](testdata/doc/watermark.png)

##### `Mergi Tool`
```bash
mergi \
-i testdata/mergi_bg_1.png \
-w "testdata/mergi_logo_watermark_90x40.png 250 10"
```

##### `Mergi Library`
```go
originalImage, _ := mergi.Import(impexp.NewFileImporter("./testdata/mergi_bg_1.png"))
watermarkImage, _ := mergi.Import(impexp.NewFileImporter("./testdata/glass-mergi_logo_watermark_90x40.jpg"))

res, _ := mergi.Watermark(watermarkImage, originalImage, image.Pt(250, 10))
mergi.Export(impexp.NewFileExporter(res, "watermark.png"))
```

 

#### 💖 Animate
Image 1 | Image 2 | Result Animation
-----------------------------------|-------------------------------------------|------------------------------------------
![srcImage](testdata/mergi_bg_1.png) | ![dstImage](testdata/mergi_bg_2.png) | ![dstImage](testdata/doc/sprite.gif)
![srcImage](testdata/mergi_bg_1.png) | ![dstImage](testdata/mergi_bg_2.png) | ![dstImage](testdata/doc/smooth.gif)

##### `Mergi Tool`
###### Sprite Animation 
```bash
mergi \
-t "TT" \
-i testdata/mergi_bg_1.png \
-i testdata/mergi_bg_2.png \
-a "sprite 50"
```
###### Smooth Animation
```bash
mergi \
-t "TT" \
-i testdata/mergi_bg_1.png \
-i testdata/mergi_bg_2.png \
-a "smooth 5"
```

##### `Mergi Library`
```go
image1, _ := mergi.Import(impexp.NewFileImporter("./testdata/mergi_bg_1.png"))
image2, _ := mergi.Import(impexp.NewFileImporter("./testdata/mergi_bg_2.png"))

gif, _ := mergi.Animate([]image.Image{image1, image2}, 50)
mergi.Export(impexp.NewAnimationExporter(gif, "out.gif"))
```

 

#### 🔥 Easing

[]() | []() | []() | []()
-----------------------|----------------------|----------------------|----------------------
![dstImage](testdata/doc/ease/InBounce.gif) <center>InBounce</center> | ![dstImage](testdata/doc/ease/InBack.gif) <center>InBack</center> | ![dstImage](testdata/doc/ease/InOutQuad.gif) <center>InOutQuad</center> | ![dstImage](testdata/doc/ease/InSine.gif) <center>InSine</center>
![dstImage](testdata/doc/ease/InCubic.gif) <center>InCubic</center> | ![dstImage](testdata/doc/ease/InElastic.gif) <center>InElastic</center> | ![dstImage](testdata/doc/ease/InOutExpo.gif) <center>InOutExpo</center> | ![dstImage](testdata/doc/ease/Linear.gif) <center>Linear</center>
![dstImage](testdata/doc/ease/InOutBounce.gif) <center>InOutBounce</center> | ![dstImage](testdata/doc/ease/InCirc.gif) <center>InCirc</center> | ![dstImage](testdata/doc/ease/InOutCubic.gif) <center>InOutCubic</center> | ![dstImage](testdata/doc/ease/InOutQuart.gif) <center>InOutQuart</center>
![dstImage](testdata/doc/ease/InOutBack.gif) <center>InOutBack</center> | ![dstImage](testdata/doc/ease/InCubic.gif) <center>InCubic</center> | ![dstImage](testdata/doc/ease/InOutCirc.gif) <center>InOutCirc</center> | ![dstImage](testdata/doc/ease/InOutSine.gif) <center>InOutSine</center>
![dstImage](testdata/doc/ease/InExpo.gif) <center>InExpo</center> | ![dstImage](testdata/doc/ease/OutBounce.gif) <center>OutBounce</center> | ![dstImage](testdata/doc/ease/InQuint.gif) <center>InQuint</center>

##### `Mergi Library`

`Note: Ease function can be applied with any function, in this example it's applied with Watermark function`
```go
// Load background and the square images
square, _ := mergi.Import(impexp.NewFileImporter("./testdata/square.jpg"))
bg, _ := mergi.Import(impexp.NewFileImporter("./testdata/white_bg.jpg"))

// Init images frames to add applied ease frames
frames := make([]image.Image, 0)

// Init the limts of the Ease
to := bg.Bounds().Max.X - square.Bounds().Max.X
posY := bg.Bounds().Max.Y/2 - square.Bounds().Max.Y/2
speed := 4

// Ease from 0 to width of background
for i := 0; i < to; i += speed {
 // Apply Easeing function InBounce
 posX := mergi.Ease(float64(i), 0, float64(to), mergi.InBounce)
 img, _ := mergi.Watermark(square, bg, image.Pt(int(posX), posY))
 frames = append(frames, img)
}

// For preview example, save as a gif
gif, _ := mergi.Animate(frames, 1)
mergi.Export(impexp.NewAnimationExporter(gif, "out.gif"))
```




 

#### 🦎 Transition

[]() | []() | []() | []()
-----------------------|----------------------|----------------------|----------------------
![dstImage](./testdata/doc/trans/SlideBar.gif) <center>SlideBar</center> | ![dstImage](./testdata/doc/trans/Ink1.gif) <center>Ink1</center> | ![dstImage](./testdata/doc/trans/Ink2.gif) <center>Ink2</center> | ![dstImage](./testdata/doc/trans/Ink3.gif) <center>Ink3</center>
![dstImage](./testdata/doc/trans/ScaleUpFastRect.gif) <center>ScaleUpFastRect</center> | ![dstImage](./testdata/doc/trans/ScaleDownFastRect.gif) <center>ScaleDownFastRect</center> | ![dstImage](./testdata/doc/trans/ScaleUpFastCircle.gif) <center>ScaleUpFastCircle</center> | ![dstImage](./testdata/doc/trans/ScaleDownFastCircle.gif) <center>ScaleDownFastCircle</center>



Learn more [examples](examples)

## 💻 Contribute

- Clone the repository
```bash
$ go get github.com/noelyahan/mergi
```
- Run unit tests
- Fix bug
- Add new feature
- Push

 

### 🌠 Contributors

 

| [<img src="https://avatars1.githubusercontent.com/u/6106461?s=460&v=4" width="100px;"/> Noel](https://twitter.com/noelyahan) 💻 📖 💬 👀 🤔 🎨 |
| :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | 


 

This project follows the [all-contributors](https://github.com/kentcdodds/all-contributors) specification.
Contributions of any kind are welcome!

 

### 🔵 License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

mergi

Storage and image processing server written in Go.

# Mort
[![Tests](https://github.com/aldor007/mort/actions/workflows/ci.yaml/badge.svg)](https://github.com/aldor007/mort/actions/workflows/ci.yaml) [![Codecov](https://img.shields.io/codecov/c/github/aldor007/mort.svg)](https://codecov.io/gh/aldor007/mort) [![Go Report Card](https://goreportcard.com/badge/github.com/aldor007/mort)](https://goreportcard.com/report/github.com/aldor007/mort) [![Godoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](https://godoc.org/github.com/aldor007/mort) [![Releases](https://img.shields.io/github/release/aldor007/mort/all.svg?style=flat-square)](https://github.com/aldor007/mort/releases) [![LICENSE](https://img.shields.io/github/license/aldor007/mort.svg?style=flat-square)](https://github.com/aldor007/mort/blob/master/LICENSE.md)

<img src="https://mort.mkaciuba.com/demo/medium/gopher.png" width="500px"/>


An S3-compatible image processing server written in Go. Still in active development.

# Features

* HTTP server
* Resize, Rotate, SmartCrop
* Convert (JPEG, PNG , BMP, Webp)
* Multiple storage backends (disk, S3, http)
* Fully modular
* S3 API for listing and uploading files
* Requests collapsing
* Build in rate limiter
* HTTP Range and Conditional requests
* Compression (gzip, brotli)
* Env variables driven configuration
* Write you own transform parser using [tengo](https://github.com/d5/tengo)
* cloudinary image transformation and upload

And more see [changelog](CHANGELOG.md) for more info

# Demo
-------
[Original image](https://mort.mkaciuba.com/demo/img.jpg)

Click on result image to see URL. More examples can be found in [Image Operations list](doc/Image-Operations.md)
<table>
 <thead>
 <tr>
 <th>Description</th>
 <th>Result (to see result click on image)</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>
 preset: small
 (preserve aspect ratio)
 width: 75 
 </td>
 <td>
 <a href="https://mort.mkaciuba.com/demo/small/img.jpg" target="_blank">
 <img src="https://mort.mkaciuba.com/demo/small/img.jpg" width="75px" />
 </a>
 </td>
 </tr>
 <tr>
 <td>
 preset: blur
 <ul>
 <li>resize image (preserve aspect ratio)
 width: 700</li>
 <li>blur image with sigma 5.0</li>
 </ul>
 </td>
 <td>
 <a href="https://mort.mkaciuba.com/demo/blur/img.jpg" target="_blank">
 <img src="https://mort.mkaciuba.com/demo/blur/img.jpg" width="700px" />
 </a>
 </td>
 </tr>
 <tr>
 <td>
 preset: webp
 <ul>
 <li> resize image (preserve aspect ratio)
 width: 1000</li>
 <li>and change format to webp</li>
 </ul>
 </td>
 <td>
 <a href="https://mort.mkaciuba.com/demo/webp/img.jpg" target="_blank">
 <img src="https://mort.mkaciuba.com/demo/webp/img.jpg" width="1000px" />
 </a>
 </td>
 </tr>
 <tr>
 <td>
 preset: watermark
 <ul>
 <li> resize image (preserve aspect ratio)
 width: 1300</li>
 <li>and add watermark</li>
 </ul>
 </td>
 <td>
 <a href="https://mort.mkaciuba.com/demo/watermark/img.jpg" target="_blank">
 <img src="https://mort.mkaciuba.com/demo/watermark/img.jpg" width="1300px" />
 </a>
 </td>
 </tr>
 </tbody>
</table>

# Usage

Mort can be used directly from the Internet and behind any proxy.


## Install

```bash
go get github.com/aldor007/mort/cmd/
```


## Command line help
```bash
$ ./mort
Usage of mort
 -config string
 	Path to configuration (default "/etc/mort/mort.yml")
```

## Configuration
Example configuration used for providing demo images:

```yaml
headers: # add or overwrite all response headers of given status. This field is optional
 - statusCodes: [200]
 values:
 "cache-control": "max-age=84000, public"

buckets: # list of available buckets
 demo: # bucket name
 keys: # list of S3 keys (optional)
 - accessKey: "access"
 secretAccessKey: "random"
 transform: # config for transforms
 path: "\\/(?P<presetName>[a-z0-9_]+)\\/(?P<parent>[a-z0-9-\\.]+)" # regexp for transform path
 kind: "presets-query" # type of transform or "query"
 presets: # list of presets
 small:
 quality: 75
 filters:
 thumbnail:
 width: 150
 blur:
 quality: 80
 filters:
 thumbnail:
 width: 700
 blur:
 sigma: 5.0
 webp:
 quality: 100
 format: webp
 filters:
 thumbnail:
 width: 1000
 watermark:
 quality: 100
 filters:
 thumbnail:
 width: 1300
 watermark:
 image: "https://i.imgur.com/uomkVIL.png"
 position: "top-left"
 opacity: 0.5
 smartcrop:
 quality: 80
 filters:
 crop:
 width: 200
 height: 200
 storages:
 basic: # retrieve originals from s3
 kind: "s3"
 accessKey: "acc"
 secretAccessKey: "sec"
 region: ""
 endpoint: "http://localhost:8080"
 transform: # and store it on disk
 kind: "local-meta"
 rootPath: "/var/www/domain/"
 pathPrefix: "transform"

```
List of all image operations can be found in [Image-Operations.md](doc/Image-Operations.md)

More details about configuration can be found in [Configuration.md](doc/Configuration.md)


## Write you own URL parser

- Using golang (custom mort version needed) [UrlParsers.md](doc/UrlParsers.md)
- Using tengo [TengoUrlParser.md](doc/TengoUrlParser.md)

## Docker
See [Dockerfile](Dockerfile) for image details.

Pull docker image

```bash
docker pull ghcr.io/aldor007/mort

```

### Create you custom docker deployment

Create Dockerfile or use Dockerfile.service
```
# Dockerfile.service 
FROM ghcr.io/aldor007/mort:latest

# add your config
ADD config.yml /etc/mort/mort.yml
```

Build container
```bash
docker build -f Dockerfile.service -t myusername/mort
```

Run docker
```
docker run -p 8080:8080 myusername/mort
```

Full example you can find [here](example/)

# Development
1. Make sure you have a Go language compiler >= 1.9 (required) and git installed.
2. Install libvips like described on [bimg page](https://github.com/h2non/bimg)
3. Ensure your GOPATH is properly set.
4. Download it
```bash
git clone https://github.com/aldor007/mort.git $GOPATH/src/github.com/aldor007/mort
cd $GOPATH/src/github.com/aldor007/mort
```
5. Install dependencies:
```bash
go mod vendor
```
Run unit tests:
```bash
make unit
```
Run integration tests:
```bash
make integrations
```

If you encounter following problem `go build gopkg.in/h2non/bimg.v1: invalid flag in pkg-config --cflags: -Xpreprocessor`
while running tests in your IDE add this to your environment:
```
export CGO_CFLAGS_ALLOW="-Xpreprocessor"
```

Run tests using docker image
```bash
make docker-tests
```

## Contributing

Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

## Inspirations

* [picfit](https://github.com/thoas/picfit)
* [imaginary](https://github.com/h2non/imaginary)

mort

Decoder and conversion tool for MPO 3D Photos.

# MPO Decoder Library

[![Go Report Card](https://goreportcard.com/badge/donatj/mpo)](https://goreportcard.com/report/donatj/mpo)
[![GoDoc](https://godoc.org/github.com/donatj/mpo?status.svg)](https://godoc.org/github.com/donatj/mpo)
[![awesome-go](https://img.shielded.dev/s?title=listed%20on&text=awesome-go&color=blue)](https://github.com/avelino/awesome-go)

Simple Go JPEG MPO (Multi Picture Object) Decoder - Library and CLI Tool

The library and CLI tool contain the ability to convert MPO to Stereoscopic JPEG as well as various color combinations of Analglyph.

A Web UI for this library exists here:

https://donatstudios.com/MPO-to-JPEG-Stereo

## Install CLI Tool

Binaries are availible for Darwin (macOS), Linux and Windows on the release page:

https://github.com/donatj/mpo/releases

### From Source

```bash
go install github.com/donatj/mpo/cmd/mpo2img@latest
```

## CLI Usage

```
mpo2img
usage: mpo2img <mpofile>
 -format string
 	Output format [stereo|red-cyan|cyan-red|red-green|green-red] (default "stereo")
 -help
 	Displays this text
 -outfile string
 	Output filename (default "output.jpg")
```

## WIP

Todo:
- Optimization
- Add Writer
- Add more control over stereo/anaglyph

Scout is a standalone open source software solution for DIY video security.

# scout

[![Github Scout](https://img.shields.io/badge/Github-Scout-blue)](https://github.com/jonoton/scout)
[![Docker Scout](https://img.shields.io/badge/Docker-Scout-blue)](https://hub.docker.com/r/jonotoninnovation/scout)

[![Android Scout](https://img.shields.io/badge/Android-Scout-blue)](https://play.google.com/store/apps/details?id=com.jonoton.scout)
[![Android Scout Lite](https://img.shields.io/badge/Android-Scout%20Lite-blue)](https://play.google.com/store/apps/details?id=com.jonoton.scout.lite)

[![Amazon Scout](https://img.shields.io/badge/Amazon-Scout-blue)](https://www.amazon.com/gp/mas/dl/android?p=com.jonoton.scout)
[![Amazon Scout Lite](https://img.shields.io/badge/Amazon-Scout%20Lite-blue)](https://www.amazon.com/gp/mas/dl/android?p=com.jonoton.scout.lite)

[![iOS Scout](https://img.shields.io/badge/iOS-Scout-blue)](https://apps.apple.com/us/app/scout-full/id1658406270)

[![Go Reference](https://pkg.go.dev/badge/github.com/jonoton/scout.svg)](https://pkg.go.dev/github.com/jonoton/scout)
[![Go Report Card](https://goreportcard.com/badge/github.com/jonoton/scout?)](https://goreportcard.com/report/github.com/jonoton/scout)
[![Docker pulls](https://img.shields.io/docker/pulls/jonotoninnovation/scout.svg)](https://hub.docker.com/r/jonotoninnovation/scout)

Scout is a standalone open source software solution for DIY video security.

[![Website Scout](https://img.shields.io/badge/Website-Scout-blue)](https://www.jonoton-innovation.com/scout)

[![Gift!](https://img.shields.io/badge/Gift!-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=RLF3ZHK79YL3W&currency_code=USD&source=url)

<img alt="Scout Android Slides" src="https://drive.google.com/uc?id=1bWH_bMtNfMIdkfRDy_bsV0PEl-DNh3KS" height="200px" style="margin:1px;" /> <img alt="Scout Web Browser Slides" src="https://drive.google.com/uc?id=1W_s4NQRkpzj-4FYlbcTaXXfYHe9eYysx" height="200px" style="margin:1px;" />

## Features
* No monthly fees!
* Easy Installation
 * Lives on your device, on your network
 * Build from source or use Docker pre-built image
 * Customize configuration with YAML
 * Link multiple servers together
* Hassle-free management
 * Need to adjust the camera? No problem! No reconfigure required!
 * No database!
 * Stores images and recordings to your local file system
 * You own your data
 * Auto-prune old data
* Computer Vision
 * Extends already proven libraries for Motion, Object, and Face detection
 * Helps reduce False Positive alerts due to issues such as spider webs or the sun peeking from behind clouds
* Alerts
 * Get notified via email or text when an alert occurs
* Recordings
 * Automatically record when objects are detected
* Continuous
 * Continuous recording with auto-prune

## Mobile Client Features
* Access your Scout server remotely
 * Home and Away settings
* Live view of monitors
 * Quick view of all monitors
 * Live Fullscreen with Pan and Zoom
* Alerts
 * Scroll through alerts
 * Alerts Fullscreen with Pan and Zoom
 * Share or Download alerts
 * Platform Notifications for Object, Person, and Face detection
* Recordings
 * Scroll through recordings
 * Recordings Fullscreen with Progressive loading
 * Share or Download recordings
* Continuous
 * Scroll through continuous recordings
 * Continuous recordings Fullscreen with Progressive loading
 * Share or Download continuous recordings

## Web Client Limited Features
* Verify setup visually
 * RAM usage
 * Frame Rate displayed
* Live view of monitors
 * Quick view of all monitors

scout

Finds good crops for arbitrary images and crop sizes.

smartcrop
=========

[![Latest Release](https://img.shields.io/github/release/muesli/smartcrop.svg)](https://github.com/muesli/smartcrop/releases)
[![Build Status](https://github.com/muesli/smartcrop/workflows/build/badge.svg)](https://github.com/muesli/smartcrop/actions)
[![Coverage Status](https://coveralls.io/repos/github/muesli/smartcrop/badge.svg?branch=master)](https://coveralls.io/github/muesli/smartcrop?branch=master)
[![Go ReportCard](https://goreportcard.com/badge/muesli/smartcrop)](https://goreportcard.com/report/muesli/smartcrop)
[![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](https://godoc.org/github.com/muesli/smartcrop)

smartcrop finds good image crops for arbitrary sizes. It is a pure Go implementation, based on Jonas Wagner's [smartcrop.js](https://github.com/jwagner/smartcrop.js)

![Example](./examples/gopher.jpg)
Image: [https://www.flickr.com/photos/usfwspacific/8182486789](https://www.flickr.com/photos/usfwspacific/8182486789) by Washington Dept of Fish and Wildlife, originally licensed under [CC-BY-2.0](https://creativecommons.org/licenses/by/2.0/) when the image was imported back in September 2014

![Example](./examples/goodtimes.jpg)
Image: [https://www.flickr.com/photos/endogamia/5682480447](https://www.flickr.com/photos/endogamia/5682480447) by Leon F. Cabeiro (N. Feans), licensed under [CC-BY-2.0](https://creativecommons.org/licenses/by/2.0/)

## Installation

Make sure you have a working Go environment (Go 1.12 or higher is required).
See the [install instructions](https://golang.org/doc/install.html).

To install smartcrop, simply run:

    go get github.com/muesli/smartcrop

To compile it from source:

    git clone https://github.com/muesli/smartcrop.git
    cd smartcrop
    go build

## Example
```go
package main

import (
	"fmt"
	"image"
	_ "image/png"
	"os"

	"github.com/muesli/smartcrop"
	"github.com/muesli/smartcrop/nfnt"
)

func main() {
	f, _ := os.Open("image.png")
	img, _, _ := image.Decode(f)

	analyzer := smartcrop.NewAnalyzer(nfnt.NewDefaultResizer())
	topCrop, _ := analyzer.FindBestCrop(img, 250, 250)

	// The crop will have the requested aspect ratio, but you need to copy/scale it yourself
	fmt.Printf("Top crop: %+v\n", topCrop)

	type SubImager interface {
		SubImage(r image.Rectangle) image.Image
	}
	croppedimg := img.(SubImager).SubImage(topCrop)
	// ...
}
```

Also see the test cases in smartcrop_test.go and cli application in cmd/smartcrop/ for further working examples.

## Simple CLI application

    go install github.com/muesli/smartcrop/cmd/smartcrop

    Usage of smartcrop:
      -height int
            crop height
      -input string
            input filename
      -output string
            output filename
      -quality int
            jpeg quality (default 85)
      -resize
            resize after cropping (default true)
      -width int
            crop width

Example:
    smartcrop -input examples/gopher.jpg -output gopher_cropped.jpg -width 300 -height 150

## Sample Data

You can find a bunch of test images for the algorithm [here](https://github.com/muesli/smartcrop-samples).

## Feedback

Got some feedback or suggestions? Please open an issue or drop me a note!

* [Twitter](https://twitter.com/mueslix)
* [The Fediverse](https://mastodon.social/@fribbledom)


smartcrop

# Steganography Lib

[![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](http://godoc.org/github.com/auyer/steganography)
[![Go Report Card](https://goreportcard.com/badge/github.com/auyer/steganography)](https://goreportcard.com/report/github.com/auyer/steganography)
[![LICENSE MIT](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://img.shields.io/badge/license-MIT-brightgreen.svg)
[![Actions CI](https://github.com/auyer/steganography/actions/workflows/test.yaml/badge.svg)](https://github.com/auyer/steganography/actions)
[![codecov](https://codecov.io/gh/auyer/steganography/branch/main/graph/badge.svg)](https://codecov.io/gh/auyer/steganography)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 

Steganography is a library written in Pure go to allow simple LSB steganography on images. It is capable of both encoding and decoding images. It can store files of any format.
This library is inspired by [Stego by EthanWelsh](https://github.com/EthanWelsh/Stego), a command line utility with the same purpose.

## Installation
```go
go get -u github.com/auyer/steganography
```

## Demonstration

| Original              |Encoded           |
| -------------------- | ------------------|
| ![Original File](examples/stegosaurus.png)  | ![Encoded File](examples/encoded_stegosaurus.png)

The second image contains the first paragraph of the description of a stegosaurus on [Wikipedia](https://en.wikipedia.org/wiki/Stegosaurus), also available in [examples/message.txt](https://raw.githubusercontent.com/auyer/steganography/master/examples/message.txt) as an example.

------
Getting Started
------
```go
package main
import (
    "bufio"
    "image/png"
    "io/ioutil"

    "github.com/auyer/steganography"
)
```

Encode
------
Write mode is used to take a message and embed it into an image file using LSB steganography in order to produce a secret image file that will contain your message.

Note that the minimum image size is 24 pixels for one byte. For each additional byte, it is necessary 3 more pixels.

```go
inFile, _ := os.Open("input_file.png") // opening file
reader := bufio.NewReader(inFile)   // buffer reader 
img, _ := png.Decode(reader)   // decoding to golang's image.Image

w := new(bytes.Buffer)   // buffer that will recieve the results
err := steganography.Encode(w, img, []byte("message")) // Encode the message into the image
if err != nil {
    log.Printf("Error Encoding file %v", err)
    return
}
outFile, _ := os.Create("out_file.png") // create file
w.WriteTo(outFile) // write buffer to it
outFile.Close()
```
note: all error checks were removed for brevity, but they should be included.

Size of Message
------
Length mode can be used in order to preform a preliminary check on the carrier image in order to deduce how large of a file it can store.

```go
sizeOfMessage := steganography.GetMessageSizeFromImage(img) // retrieves the size of the encoded message
```

Decode
-----
Read mode is used to read an image that has been encoded using LSB steganography, and extract the hidden message from that image.

```go
inFile, _ := os.Open(encodedInputFile) // opening file
defer inFile.Close()

reader := bufio.NewReader(inFile) // buffer reader 
img, _ := png.Decode(reader) // decoding to golang's image.Image

sizeOfMessage := steganography.GetMessageSizeFromImage(img) // retrieving message size to decode in the next line

msg := steganography.Decode(sizeOfMessage, img) // decoding the message from the file
fmt.Println(string(msg))

```
note: all error checks were removed for brevity, but they should be included.

Complete Example
------
For a complete example, see the [examples/stego.go](examples/stego.go) file. It is a command line app based on the original fork of this repository, but modified to use the Steganography library.

-----
### Attributions
 - Stegosaurus Picture By Matt Martyniuk - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=42215661


steganography

Go tool for LSB steganography, capable of hiding any file within an image.

# stegify
[![Build Status](https://travis-ci.org/DimitarPetrov/stegify.svg?branch=master)](https://travis-ci.org/DimitarPetrov/stegify)
[![Coverage Status](https://coveralls.io/repos/github/DimitarPetrov/stegify/badge.svg?branch=master)](https://coveralls.io/github/DimitarPetrov/stegify?branch=master)
[![GoDoc](https://godoc.org/github.com/DimitarPetrov/stegify?status.svg)](https://godoc.org/github.com/DimitarPetrov/stegify)
[![Go Report Card](https://goreportcard.com/badge/github.com/DimitarPetrov/stegify)](https://goreportcard.com/report/github.com/DimitarPetrov/stegify)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 


## Overview
`stegify` is a simple command line tool capable of fully transparent hiding any file within an image or set of images.
This technique is known as LSB (Least Significant Bit) [steganography](https://en.wikipedia.org/wiki/steganography) 

## Demonstration

| Carrier | Data | Result |
| ---------------------------------------| ------------------------------------|------------------------------------------------------|
| ![Original File](examples/street.jpeg) | ![Data file](examples/lake.jpeg) | ![Encoded File](examples/test_decode.jpeg) |

The `Result` file contains the `Data` file hidden in it. And as you can see it is fully transparent.

If multiple `Carrier` files are provided, the `Data` file will be split in pieces and every piece is encoded in the respective carrier.

| Carrier1 | Carrier2 | Data | Result1 | Result2 |
| ---------------------------------------------|--------------------------------------------|--------------------------------------------|------------------------------------------------------------------|------------------------------------------------------------------|
| <img src="examples/street.jpeg" width="500"> | <img src="examples/lake.jpeg" width="500"> | <img src="examples/video.gif" width="500"> | <img src="examples/test_multi_carrier_decode1.jpeg" width="500"> | <img src="examples/test_multi_carrier_decode2.jpeg" width="500"> |
 
The `Result1` file contains one half of the `Data` file hidden in it and `Result2` the other. As always fully transparent.

## Installation

#### Installing from Source
```
go install github.com/DimitarPetrov/stegify@latest
```

#### Installing via Homebrew (macOS)
```
brew tap DimitarPetrov/stegify
brew install stegify
```

Or you can download a binary for your system [here](https://github.com/DimitarPetrov/stegify/releases).

## Usage

### As a command line tool

#### Single carrier encoding/decoding
```
stegify encode --carrier <file-name> --data <file-name> --result <file-name>

stegify decode --carrier <file-name> --result <file-name>
```
When encoding, the file with name given to flag `--data` is hidden inside the file with name given to flag
`--carrier` and the resulting file is saved in new file in the current working directory under the
name given to flag `--result`.

> **_NOTE:_** The result file won't have any file extension and therefore it should be specified explicitly in `--result` flag. 

When decoding, given a file name of a carrier file with previously encoded data in it, the data is extracted
and saved in new file in the current working directory under the name given to flag `--result`.

> **_NOTE:_** The result file won't have any file extension and therefore it should be specified explicitly in `--result` flag.

In both cases the flag `--result` could be omitted and default values will be used.

#### Multiple carriers encoding/decoding

```
stegify encode --carriers "<file-names...>" --data <file-name> --results "<file-names...>"
OR
stegify encode --carrier <file-name> --carrier <file-name> ... --data <file-name> --result <file-name> --result <file-name> ...

stegify decode --carriers "<file-names...>" --result <file-name>
OR
stegify decode --carrier <file-name> --carrier <file-name> ... --result <file-name>
```
When encoding a data file in more than one carriers, the data file is split in *N* chunks, where *N* is number of provided carriers.
Each of the chunks is then encoded in the respective carrier.

> **_NOTE:_** When decoding, carriers should be provided in the **exact** same order for result to be properly extracted. 

This kind of encoding provides one more layer of security and more flexibility regarding size limitations.

In both cases the flag `--result/--results` could be omitted and default values will be used.

> **_NOTE:_** When encoding the number of the result files (if provided) should be equal to the number of carrier files. When decoding, exactly one result is expected. 

When multiple carriers are provided with mixed kinds of flags, the names provided through `carrier` flag are taken first and with `carriers/c` flags second.
Same goes for the `result/results` flag.


### Programmatically in your code

`stegify` can be used programmatically too and it provides easy to use functions working with file names
or raw Readers and Writers. You can visit [godoc](https://godoc.org/github.com/DimitarPetrov/stegify) under
`steg` package for details.

## Disclaimer

If carrier file is in jpeg or jpg format, after encoding the result file image will be png encoded (therefore it may be bigger in size)
despite of file extension specified in the result flag.

## Showcases

### 🚩 Codefest’19

`stegify` was used for one of the *Capture The Flag* challenges in [**Codefest’19**](https://www.hackerrank.com/codefest19-ctf).

Participants were given a photo of a bunch of "innocent" cats. Nothing suspicious right? Think again!

You can read more [here](https://medium.com/bugbountywriteup/codefest19-ctf-writeups-a8f4e9b45d1) and [here](https://medium.com/@markonsecurity/image-challenges-1-cats-are-innocent-right-69cd4220bc99).

stegify

svgo

Package tga is a TARGA image format decoder/encoder.

# tga

tga is a [Go](http://golang.org/) package for decoding and encoding TARGA image
format.

It supports RLE and raw TARGA images with 8/15/16/24/32 bits per pixel,
monochrome, truecolor and colormapped images. It also correctly handles origins,
attribute type in extensions area and successfully passes TGA 2.0 conformance
suite (http://googlesites.inequation.org/tgautilities).

Encoding an image doesn't involve conversion if it's `image.Gray`, `image.RGBA`
or `image.NRGBA`. Other types are converted to `image.NRGBA` prior to encoding.

## Installation

    $ go get github.com/ftrvxmtrx/tga

## Documentation and examples

[tga on godoc.org](http://godoc.org/github.com/ftrvxmtrx/tga)

## License

Code is licensed under the MIT license (see `LICENSE.MIT`).

Several sample image files in `testdata` directory are copyright to TrueVision,
Inc. and are freely available, free of charge and under no licensing terms at
http://googlesites.inequation.org/tgautilities

These sample images (and those which were converted from them) are:
```
bw.png
cbw8.tga
ccm8.tga
color.png
ctc16.tga
ctc24.tga
ctc32.tga
ubw8.tga
ucm8.tga
utc16.tga
utc24.tga
utc32.tga
```


Transformimgs resizes and optimises images for Web using next-generation formats.

<img src="logo.png" alt="logo"/>


# TransformImgs

[![Go Reference](https://pkg.go.dev/badge/github.com/Pixboost/transformimgs/v8.svg)](https://pkg.go.dev/github.com/Pixboost/transformimgs/v8)
![Go Report Card](https://goreportcard.com/badge/github.com/Pixboost/transformimgs/v8)
![Build Status](https://github.com/Pixboost/transformimgs/actions/workflows/action.yml/badge.svg)
[![codecov](https://codecov.io/gh/Pixboost/transformimgs/branch/main/graph/badge.svg)](https://codecov.io/gh/Pixboost/transformimgs)
[![Docker Pulls](https://img.shields.io/docker/pulls/pixboost/transformimgs)](https://hub.docker.com/r/pixboost/transformimgs/)
[![Docker Automated build](https://img.shields.io/docker/automated/jrottenberg/ffmpeg.svg)](https://hub.docker.com/r/pixboost/transformimgs/)

Open Source [Image CDN](https://web.dev/image-cdns/) that provides image transformation API and supports 
the latest image formats, such as WebP, AVIF, Jpeg XL, and network client hints. 


## Table of Contents


- [Why?](#why)
- [Features](#features)
- [Quickstart](#quickstart)
- [API](#api)
- [Running](#running-locally)
 * [Docker](#docker)
 * [Options](#options)
 * [Running Locally From Source Code](#running-from-source-code)
 * [Using from Go Web Application](#using-from-go-web-application)
- [SaaS](#saas)
- [Performance tests](#performance-tests)
- [Opened tickets for images related features](#opened-tickets-for-images-related-features)
- [Contribute](#contribute)
- [License](#license)
- [Todo](#todo)


## Why?

[We wrote a big blog on this](https://pixboost.com/blog/why-pixboost-is-the-best-image-cdn/), and here is TLDR:

Transformimgs is an image CDN for Web, so API must cover typical use cases, like
thumbnails, zoom in product images, etc. Any new API endpoints must 
solve the above problems.

The goal is to have zero-config API that makes decisions based on the input, so you don't need to provide additional parameters like quality, output format, type of compression, etc.

Therefore, this allows you to configure the integration once. New features, like new image formats, will work
with your front end automatically without any changes.

To achieve that goal we should keep API to bare minimum and hide the smartness in the implementation. 

## Features

* Resize/optimises/crops raster (PNG and JPEG) images.
* [JpegXL](https://jpegxl.info/) / [AVIF](https://en.wikipedia.org/wiki/AV1) / [WebP](https://developers.google.com/speed/webp/) support based on "Accept" header.
* [Vary](www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.44) header support - ready to deploy behind any CDN.
* Responsive images support including high DPI (retina) displays 
* [Save-Data](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Save-Data) support

## Quickstart

There is an example of running API behind reverse proxy with integration example in `quickstart/` folder.

To run:

```
cd quickstart
docker-compose up
open https://localhost
```

## API

The API has 4 HTTP endpoints:

* /img/{IMG_URL}/optimise - optimises image
* /img/{IMG_URL}/resize - resizes image
* /img/{IMG_URL}/fit - resize image to the exact size by resizing and cropping it
* /img/{IMG_URL}/asis - returns original image

Docs:
* [Swagger-UI](https://pixboost.com/docs/api/) - use API key `MjUyMTM3OTQyNw__` which allows to transform any image from unsplash.com
* [OpenAPI spec](swagger.yaml)

## Running Locally

### Docker

The latest docker image published on [Docker hub](https://hub.docker.com/r/pixboost/transformimgs)

Starting the server:

```
$ docker run -p 8080:8080 pixboost/transformimgs [OPTIONS]
```

To verify:

* Health check: `curl http://localhost:8080/health`
* Transformation: `open http://localhost:8080/img/https://images.unsplash.com/photo-1591769225440-811ad7d6eab3/resize?size=600`

### Options

Everything below is optional and have sensible defaults.

| Option | Description | Default |
|--------|-------------| ------- |
| cache | Number of seconds to cache image(0 to disable cache). Used in max-age HTTP response. | 2592000 (30 days) |
| proc | Number of images processors to run. | Number of CPUs (cores) |
| disableSaveData | If set to true then will disable Save-Data client hint. Should be disabled on CDNs that don't support Save-Data header in Vary. | false |

### Running from source code

Prerequisites:

* Go 1.18+ with [modules support](https://golang.org/ref/mod)
* Installed [imagemagick v7.0.25+](http://imagemagick.org) with AVIF support in `/usr/local/bin`

Install illustration command:

```bash
cd illustration/
go install
```

Run the application:

```bash
./run.sh 
```

### Using from Go Web Application

You could also easily plugin HTTP route into your existing web application 
using service.GetRouter method. Here is a quick [example of how to do that](./example_test.go). 

## SaaS

We run SaaS version at [pixboost.com](https://pixboost.com?source=github) with generous free tier.

Perks of SaaS version:
* CDN with HTTP/3 support included
* Dashboard with usage monitor
* API Key support with domains allow list
* AWS S3 integration
* API workflows for cache busting and warmup
* Version upgrades

Go modules have been introduced in v6.

## Performance tests

There is a [JMeter](https://jmeter.apache.org) performance test you can run against a service. To run tests:

* Start a performance test environment:
```
$ docker-compose -f docker-compose-perf.yml up
```
* Run JMeter tests:
```
$ jmeter -n -t perf-test.jmx -l ./results.jmx -e -o ./results
```

* Run JMeter WebP test:
```
$ jmeter -n -t perf-test-webp.jmx -l ./results-webp.jmx -e -o ./results-webp
```

* Run JMeter AVIF test:
```
$ jmeter -n -t perf-test-avif.jmx -l ./results-avif.jmx -e -o ./results-avif
```

* Run JMeter JPEG XL test:
```
$ jmeter -n -t perf-test-jxl.jmx -l ./results-jxl.jmx -e -o ./results-jxl
```


## Opened tickets for images related features

* [Safari to support Save-Data](https://bugs.webkit.org/show_bug.cgi?id=199101)
* [Auto sizes for lazy loaded img in Firefox](https://bugzilla.mozilla.org/show_bug.cgi?id=1816615)
* [Auto sizes for lazy loaded img in Safari](https://bugs.webkit.org/show_bug.cgi?id=253143)

## Contribute

Shout out with any ideas. PRs are more than welcome.

## License

[MIT](./LICENSE)

## Todo
* ~~Add JpegXR support~~ (IE supports WEBP)
* ~~Add Jpeg 2000 support~~ (Safari support WEBP)
* [Client Hints](https://github.com/Pixboost/transformimgs/issues/26) - on hold due to browsers adoption
* ~~[Save-Data header](https://github.com/Pixboost/transformimgs/issues/27)~~ (Added in version 7.0.0)
* [SVG support](https://github.com/Pixboost/transformimgs/issues/12)
* Consider using [Zopfli](https://github.com/google/zopfli) or [Brotli](https://en.wikipedia.org/wiki/Brotli) for PNGs
* ~~JpegXL Support since supported by Safari 17~~ (Added in version 8.12.0)
* ~~GIF support~~ (Added in version 6.1.0)

transformimgs

Simple and minimal image server capable of storing, resizing, converting and caching images.

# webp-server

[![Coverage Status](https://coveralls.io/repos/github/mehdipourfar/webp-server/badge.svg?branch=master)](https://coveralls.io/github/mehdipourfar/webp-server?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/mehdipourfar/webp-server)](https://goreportcard.com/report/github.com/mehdipourfar/webp-server)
[![Release](https://img.shields.io/github/v/release/mehdipourfar/webp-server?sort=semver)](https://github.com/mehdipourfar/webp-server/releases)
[![Github Workflow Status](https://github.com/mehdipourfar/webp-server/workflows/test/badge.svg)](https://github.com/mehdipourfar/webp-server/actions?query=workflow%3Atest)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go#images)

Simple and minimal image server capable of storing, resizing, converting, and caching images. You can quickly find out how it works by looking at the flowchart below.


 <img src="https://github.com/mehdipourfar/webp-server/raw/master/docs/flowchart.jpg" alt="Flowchart"/>



## Contents

- [Quickstart](#quickstart)
- [FAQ](#faq)
- [Installation](#installation)
 - [Docker](#docker)
 - [Download Binary](#download-binary)
 - [Build From Source](#build-from-source)
- [Configuration](#configuration)
- [Backend APIs](#backend-apis)
- [Frontend APIs](#frontend-apis)
- [Reverse Proxy](#reverse-proxy)


## Quickstart
Run a docker container of `webp-server`.
```sh
docker run -d -v webp_server_volume:/var/lib/webp-server --name webp-server -e TOKEN='MY_STRONG_TOKEN' -p 127.0.0.1:8080:8080 ms68/webp-server
```
Upload an image:

``` sh
curl -H 'Token: MY_STRONG_TOKEN' -X POST -F 'image_file=@/path/to/image.jpg' http://127.0.0.1:8080/upload/

# this api will return an image_id
```

Open these urls in your browser.

```
http://127.0.0.1:8080/image/width=500,height=500,fit=contain,quality=100/{image_id}
http://127.0.0.1:8080/image/width=300,height=300,fit=cover,quality=90/{image_id}
```

For supporting more image sizes and qualities, you should edit the config file which resides in `webp_server_volume`:

``` sh
docker volume ls -f name=webp_server_volume --format "{{ .Mountpoint }}"
```

And then, restart the server:

``` sh
docker container restart webp-server
```



## FAQ
* ### What is webp-server?
 `webp-server` is a dynamic image resizer and format converter server built on top of [libvips](https://github.com/libvips/libvips), [bimg](https://github.com/h2non/bimg), and [fasthttp](https://github.com/valyala/fasthttp). Backend developers can run this program on their server machines and upload images to it instead of storing them. It will return an `image_id` which needs to be saved on a database by the backend application (on a `varchar` field with a length of at least 12).
 By using that `image_id`, web clients can request images from `webp-server` and get them in the appropriate size and format.

 Here is an example request URL for an image cropped to 500x500 size.

 ```code
 https://example.com/image/w=500,h=500,fit=cover/(image_id)
 ```

* ### What are the benfits of serving images in WebP format?
 According to Google Developers website:
 > WebP is a modern image format that provides superior lossless and lossy compression for images on the web. Using WebP, webmasters and web developers can create smaller, richer images that make the web faster.

 Although nowadays most web browsers support WebP, less than 1% of websites serve their images in this format. That's maybe because converting images to WebP can be complicated and time-consuming or developers don't know what to do with the browsers which don't support WebP.

* ### What can webp-server do about the browsers which don't support WebP?
 When browsers request an image, they will send an accept header containing supported image formats. `webp-server` will lookup that header to see if the browser supports WebP or not. If not, it will send the image in JPEG.

* ### Isn't it resource expensive to convert images on each request?
 Yes, it is. For this reason, `webp-server` will cache each converted image after the first request.

* ### What about security topics such as DOS attacks or heavy storage usage?
 It is up to you. You can limit the combinations of widths and heights or qualities that you accept from the client in `webp-server` configuration file, and by doing that you will narrow down the type of accepted requests for generating images. In case of serving requests from the cache, powered by `fasthttp`, `webp-server` can be blazingly fast.

* ### Can web clients upload images to `webp-server` and send the `image_id` to a web server?
 It is strongly recommended not to do this and also do not share your `webp-server` token with frontend applications for security reasons. Process should be like this: Frontend uploads the image to the backend, backend uploads it to wepb-server, and stores the returning `image_id` in database.

* ### What is the advantage of using `webp-server` instead of similar projects?
 It is simple and minimal and has been designed to work along with the backend applications for serving images of websites in WebP format. It does not support all kinds of manipulations that one can do with images. It does a few things and tries to do them perfectly.


## Installation
There are two methods for running `webp-server`. Either use docker or build it yourself:

### Docker

```sh
docker run -d -v webp_server_volume:/var/lib/webp-server --name webp-server -e TOKEN='MY_STRONG_TOKEN' -p 127.0.0.1:8080:8080 ms68/webp-server
```

### Download Binary
`webp-server` is depending on libvips=>8.9. On Ubuntu 20.04 You can install it By the command below:

``` sh
sudo apt install libvips
```
After installation, you can check your `libvips` version by running this command:

```sh
vips -v
```
Download the binary from here:

``` sh
wget https://github.com/mehdipourfar/webp-server/releases/download/v1.0.0/webp-server_1.0.0_linux_amd64.tar.gz
```

### Build From Source

``` sh
sudo apt install libvips-dev git


## in Case you don't have Golang installed on your system.

wget https://golang.org/dl/go1.15.6.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.15.6.linux-amd64.tar.gz
export GOPATH=$HOME/go
export PATH=$PATH:/usr/local/go/bin

go get -u -v github.com/mehdipourfar/webp-server
sudo cp $HOME/go/bin/webp-server /usr/bin/


# Download and edit `example-config.yml` to your desired config
wget https://raw.githubusercontent.com/mehdipourfar/webp-server/master/example-config.yml

# Run the server:
webp-server -config example-config.yml

```


## Configuration
There is an example configuration file [example-config.yml](https://github.com/mehdipourfar/webp-server/blob/master/example-config.yml) in the code directory. Here is the list of parameters that you can configure:

* `data_dir`: Data directory in which images and cached images are stored. Note that in this directory, there will be two separate directories named `images` and `caches`. You can remove the caches directory at any point in time if you wanted to free up some disk space.

* `server_address`: Combination of ip:port. Default value is 127.0.0.1:8080.

* `token`: The token that your backend application should send in the request header for upload and delete operations.

* `default_image_quality`: When converting images, `webp-server` uses this value for conversion quality in case the user omits the quality option in the request. The default value is 95. By decreasing this value, size and quality of the image will be decreased.

* `valid_image_qualities`: List of integer values from 10 to 100 which will be
accepted from users as the quality option.
(Narrow down these values to prevent attackers from creating too many cache files for your images.)

* `valid_image_sizes`: List of string values in (width)x(height) format which will be accepted from users as width and height options. In case you want your users to be able to set width=500 without providing height, you can add 500x0 to the values list.
(Narrow down these values to prevent attackers from creating too many cache files for your images.)

* `max_uploaded_image_size`: Maximum size of accepted uploaded images in Megabytes.

* `debug`: When set to `true` `/image/` API does not check if width, height, and quality are included in `valid_image_sizes` and `valid_image_qualities`. It can be useful when you are developing your frontend applications and you are not yet sure which sizes and qualities you want. But do not set it to `true` on production server.


## Backend APIs
* `/upload/ [Method: POST]`: Accepts image in multipart/form-data format with a field name of `image_file`. You should also pass the `Token` previously set in your configuration file as a header. All responses are in JSON format. If request is successful, you will get `200` status code with such body: `{"image_id": "lulRDHbMg"}` (Note that `image_id` length can vary from 9 to 12). Otherwise, depending on the error, you will get `4xx` or `5xx` status code with a body like this: `{"error": "reason of error"}`.

 Example:
 ```sh
 curl -H 'Token: 456e910f-3d07-470d-a862-1deb1494a38e' -X POST -F 'image_file=@/path/to/image.png' http://127.0.0.1:8080/upload/
 ```

* `/delete/(image_id) [Method: DELETE]`: Accepts `image_id` as URL parameter. If the image is deleted without a problem, the server will return `204` status code with an empty body. Otherwise, it will return `4xx` or `5xx` with an error message in JSON format.

 Example:
 ```sh
 curl -H 'Token: 456e910f-3d07-470d-a862-1deb1494a38e' -X DELETE "http://localhost:8080/delete/lulRDHbMg";
 ```

* `/health/ [Method: GET]`: It returns `200` status code if the server is up and running. It can be used by container managers to check the status of a `webp-server` container.


## Frontend APIs
* `/image/(image_id) [Method: GET]`: Returns the image which has been uploaded to `webp-server` in original size and format.

* `/image/(filter_options)/(image_id) [Method: GET]`: Returns the filtered image with content-type based on `Accept` header of the browser. Filter options can be these parameters:
 * `w`, `width`: Width of the requested image.
 * `h`, `height`: Height of the requested image.
 * `q`, `quality`: Quality of the requested image. The default value should be set in the server config.
 * `fit`: Accepts `cover`, `contain` and `scale-down` as value.
 * `contain`: Image will be resized (shrunk or enlarged) to be as large as possible within the given `width` or `height` while preserving the aspect ratio. This is the default value for fit.
 * `scale-down`: Image will be shrunk in size to fully fit within the given `width` or `height`, but won’t be enlarged.
 * `cover`: Image will be resized to exactly fill the entire area specified by `width` and `height`, and will cropped if necessary.

Some example image urls:
```
http://example.com/image/w=500,h=500/lulRDHbMg
http://example.com/image/w=500,h=500,q=95/lulRDHbMg
http://example.com/image/w=500,h=500,fit=cover/lulRDHbMg
http://example.com/image/w=500,h=500,fit=contain/lulRDHbMg
http://example.com/image/w=500,fit=contain/lulRDHbMg
```

## Reverse Proxy

`webp-server` does not support SSL or domain name validation. It is recommended to use a reverse proxy such as [nginx](https://www.nginx.com/) in front of it. It should only cover frontend APIs. Backend APIs should be called locally. Here is a minimal `nginx` configuration that redirects all the paths which start with `/image/` to `webp-server`.

``` nginx

upstream webp_server {
 server 127.0.0.1:8080 fail_timeout=0;
}

server {
 # ...

 location /image/ {
 proxy_redirect off;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Scheme $scheme;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 proxy_set_header X-Forwarded-Protocol $scheme;
 proxy_pass http://webp_server;
 }
}

```

## Security Checklist
* Set `debug` config to `false` value in production.
* Narrow down `valid_image_qualities` and `valid_image_sizes` to the values you really want.
* From the outside of the server, `webp-server` address should not be accessible, and users should only be able to see the `/image/` path through your reverse proxy.

The Best Go Libraries For Images (26)