# Cameron

[![Test](https://github.com/aofei/cameron/actions/workflows/test.yaml/badge.svg)](https://github.com/aofei/cameron/actions/workflows/test.yaml)
[![codecov](https://codecov.io/gh/aofei/cameron/branch/master/graph/badge.svg)](https://codecov.io/gh/aofei/cameron)
[![Go Report Card](https://goreportcard.com/badge/github.com/aofei/cameron)](https://goreportcard.com/report/github.com/aofei/cameron)
[![Go Reference](https://pkg.go.dev/badge/github.com/aofei/cameron.svg)](https://pkg.go.dev/github.com/aofei/cameron)

An avatar generator for Go.

Fun fact, Cameron is named after [James Cameron](https://en.wikipedia.org/wiki/James_Cameron), the director of
[Avatar](https://en.wikipedia.org/wiki/Avatar_(2009_film)).

## Features

- Pixel-perfect [GitHub Identicons](https://github.blog/news-insights/company-news/identicons/)
- Zero third-party dependencies

## Installation

To use this project programmatically, `go get` it:

```bash
go get github.com/aofei/cameron
```

## Quickstart

Create a file named `cameron.go`:

```go
package main

import (
	"image/png"
	"net/http"

	"github.com/aofei/cameron"
)

func main() {
	http.ListenAndServe("localhost:8080", http.HandlerFunc(identicon))
}

func identicon(rw http.ResponseWriter, req *http.Request) {
	img := cameron.Identicon([]byte(req.RequestURI), 70)
	rw.Header().Set("Content-Type", "image/png")
	png.Encode(rw, img)
}
```

Then run it:

```bash
go run cameron.go
```

Finally, visit `http://localhost:8080` with different paths.

## Community

If you have any questions or ideas about this project, feel free to discuss them
[here](https://github.com/aofei/cameron/discussions).

## Contributing

If you would like to contribute to this project, please submit issues [here](https://github.com/aofei/cameron/issues) or
pull requests [here](https://github.com/aofei/cameron/pulls).

When submitting a pull request, please make sure its commit messages adhere to
[Conventional Commits 1.0.0](https://www.conventionalcommits.org/en/v1.0.0/).

## License

This project is licensed under the [MIT License](LICENSE).


cameron

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

# Darkroom - Yet Another Image Proxy

<img src="website/static/img/darkroom-logo.png" width="360">

[![build status](https://travis-ci.com/gojek/darkroom.svg?branch=master)](https://travis-ci.com/gojek/darkroom)
[![Coverage Status](https://coveralls.io/repos/github/gojek/darkroom/badge.svg?branch=master)](https://coveralls.io/github/gojek/darkroom?branch=master)
[![Docs latest](https://img.shields.io/badge/Docs-latest-blue.svg)](https://gojek.github.io/darkroom/)
[![GoDoc](https://godoc.org/github.com/gojek/darkroom?status.svg)](https://godoc.org/github.com/gojek/darkroom)
[![Go Report Card](https://goreportcard.com/badge/github.com/gojek/darkroom)](https://goreportcard.com/report/github.com/gojek/darkroom)
[![GolangCI](https://golangci.com/badges/github.com/gojek/darkroom.svg)](https://golangci.com)
[![GitHub Release](https://img.shields.io/github/release/gojek/darkroom.svg?style=flat)](https://github.com/gojek/darkroom/releases)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 

## Introduction

[Darkroom](https://gojek.github.io/darkroom/) combines the [storage backend](pkg/storage) and the [image processor](pkg/processor) and acts as an `Image Proxy` on your image source. 
You may [implement](https://gojek.github.io/darkroom/docs/customization#custom-storage-example) your own `Storage` and `Processor` interfaces to gain custom functionality while still keeping other Darkroom Server functionality. 
The native implementations focus on speed and resiliency.

## Features

Darkroom supports several image operations which are documented [here](https://gojek.github.io/darkroom/docs/usage/size).

## Installation

```bash
go get -u github.com/gojek/darkroom
```
Other ways to run can be found [here](https://gojek.github.io/darkroom/docs/getting-started#running-the-image-proxy-service).

## Metrics Support

Darkroom supports Prometheus and StatsD for tracking and monitoring metrics.
You need to specify the metrics system by adding an environment variable, `METRICS_SYSTEM=prometheus/statsd`
### Prometheus
The application exposes the metrics at "http://<application_url>/metrics" endpoint. Since it's a pull based system, Prometheus server that is set up from docker-compose scrapes metrics from the application endpoint and its configuration can be changed in prometheus.yml. 
### StatsD
In order to use StatsD as your metrics system, you also need to add the following env variables, 
```
METRICS_STATSD_STATSDADDR=hostname:port
METRICS_STATSD_PREFIX=client-prefix
METRICS_STATSD_SAMPLERATE=sample-rate
METRICS_STATSD_FLUSHBYTES=flushbytes
```
These are used to set up the StatsD client.
### Grafana
Darkroom currently supports grafana provisioning for Prometheus based metrics.

Grafana is preconfigured with dashboards and Prometheus as the default data source:

* Name: Prometheus
* Type: Prometheus
* Url: http://prometheus:9090
* Access: proxy

Visualization of Darkroom metrics(prometheus) on Grafana:

<img src="deployments/grafana/provisioning/dashboards/dashboard_example.png">

### Contributing Guide

Read our [contributing guide](./CONTRIBUTING.md) to learn about our development process, how to propose bugfixes and improvements, and how to build and test your changes to Darkroom.

## License

Darkroom is [MIT licensed](./LICENSE).

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
  transform   apply geometric transformations to images

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

To resize an image to 800x600 using the lanczos filter:
```
bild transform resize --width 800 --height 600 --filter lanczos input.png output.png
```

To rotate an image 90 degrees clockwise, expanding bounds to fit:
```
bild transform rotate --angle 90 --resize-bounds input.png output.png
```

To crop an image to a specific region:
```
bild transform crop --rect 0x0+512x256 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)

### Zoom
    // Zoom in 2x, preserving the image size (out-of-bounds pixels are cropped)
    result := transform.Zoom(img, 2.0, nil)

    // Zoom in 2x, expanding the canvas to fit the full zoomed image
    result := transform.Zoom(img, 2.0, &transform.ZoomOptions{ResizeBounds: true})

    // Zoom with a custom pivot point
    result := transform.Zoom(img, 2.0, &transform.ZoomOptions{Pivot: &image.Point{0, 0}})


## 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 [![GoDoc](https://godoc.org/github.com/h2non/bimg?status.svg)](https://godoc.org/github.com/h2non/bimg) [![Coverage Status](https://coveralls.io/repos/github/h2non/bimg/badge.svg?branch=master)](https://coveralls.io/github/h2non/bimg?branch=master) ![License](https://img.shields.io/badge/license-MIT-blue.svg)

Small [Go](http://golang.org) package for fast high-level image processing using [libvips](https://github.com/jcupitt/libvips) via C bindings, providing a simple [programmatic API](#examples).

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

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

bimg uses internally libvips, a powerful library written in C for image processing which requires a [low memory footprint](https://github.com/jcupitt/libvips/wiki/Speed_and_Memory_Use)
and it's typically 4x faster than using the quickest ImageMagick and GraphicsMagick settings or Go native `image` package, and in some cases it's even 8x faster processing JPEG images.

If you're looking for an HTTP based image processing solution, see [imaginary](https://github.com/h2non/imaginary).

bimg was heavily inspired in [sharp](https://github.com/lovell/sharp), its homologous package built for [node.js](http://nodejs.org). bimg is used in production environments processing thousands of images per day.

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

## Contents

- [Supported image operations](#supported-image-operations)
- [Prerequisites](#prerequisites)
- [Installation](#installation)
- [Performance](#performance)
- [Benchmark](#benchmark)
- [Examples](#examples)
- [Debugging](#debugging)
- [API](#api)
- [Authors](#authors)
- [Credits](#credits)

## Supported image operations

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

## Prerequisites

- [libvips](https://github.com/libvips/libvips) 8.3+ (8.8+ recommended)
- C compatible compiler such as gcc 4.6+ or clang 3.0+
- Go 1.3+

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

## Installation

```bash
go get -u github.com/h2non/bimg
```

### libvips

Follow `libvips` installation instructions:

[https://libvips.github.io/libvips/install.html](https://libvips.github.io/libvips/install.html)

##### Installation script

**Note**: install script is officially deprecated, it might not work as expected. We recommend following [libvips install](https://libvips.github.io/libvips/install.html) instructions.

Run the following script as `sudo` (supports OSX, Debian/Ubuntu, Redhat, Fedora, Amazon Linux):
```bash
curl -s https://raw.githubusercontent.com/h2non/bimg/master/preinstall.sh | sudo bash -
```

If you want to take the advantage of [OpenSlide](http://openslide.org/), simply add `--with-openslide` to enable it:
```bash
curl -s https://raw.githubusercontent.com/h2non/bimg/master/preinstall.sh | sudo bash -s --with-openslide
```

The [install script](https://github.com/h2non/bimg/blob/master/preinstall.sh) requires `curl` and `pkg-config`.

## Performance

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

- [libvips speed and memory usage](https://github.com/jcupitt/libvips/wiki/Speed-and-memory-use)

## Benchmark

Tested using Go 1.5.1 and libvips-7.42.3 in OSX i7 2.7Ghz
```
BenchmarkRotateJpeg-8     	      20	  64686945 ns/op
BenchmarkResizeLargeJpeg-8	      20	  63390416 ns/op
BenchmarkResizePng-8      	     100	  18147294 ns/op
BenchmarkResizeWebP-8     	     100	  20836741 ns/op
BenchmarkConvertToJpeg-8  	     100	  12831812 ns/op
BenchmarkConvertToPng-8   	      10	 128901422 ns/op
BenchmarkConvertToWebp-8  	      10	 204027990 ns/op
BenchmarkCropJpeg-8       	      30	  59068572 ns/op
BenchmarkCropPng-8        	      10	 117303259 ns/op
BenchmarkCropWebP-8       	      10	 107060659 ns/op
BenchmarkExtractJpeg-8    	      50	  30708919 ns/op
BenchmarkExtractPng-8     	    3000	    595546 ns/op
BenchmarkExtractWebp-8    	    3000	    386379 ns/op
BenchmarkZoomJpeg-8       	      10	 160005424 ns/op
BenchmarkZoomPng-8        	      30	  44561047 ns/op
BenchmarkZoomWebp-8       	      10	 126732678 ns/op
BenchmarkWatermarkJpeg-8  	      20	  79006133 ns/op
BenchmarkWatermarPng-8    	     200	   8197291 ns/op
BenchmarkWatermarWebp-8   	      30	  49360369 ns/op
```

## Examples

```go
import (
  "fmt"
  "os"
  "github.com/h2non/bimg"
)
```

#### Resize

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

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

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

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

#### Rotate

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

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

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

#### Convert

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

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

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

#### Force resize

Force resize operation without preserving the aspect ratio:

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

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

size := bimg.Size(newImage)
if size.Width != 1000 || size.Height != 500 {
  fmt.Fprintln(os.Stderr, "Incorrect image size")
}
```

#### Custom colour space (black & white)

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

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

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

#### Custom options

See [Options](https://godoc.org/github.com/h2non/bimg#Options) struct to discover all the available fields

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

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

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

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

#### Watermark

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

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

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

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

#### Fluent interface

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

image := bimg.NewImage(buffer)

// first crop image
_, err := image.CropByWidth(300)
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

// then flip it
newImage, err := image.Flip()
if err != nil {
  fmt.Fprintln(os.Stderr, err)
}

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

## Debugging

Run the process passing the `DEBUG` environment variable
```
DEBUG=bimg ./app
```

Enable libvips traces (note that a lot of data will be written in stdout):
```
VIPS_TRACE=1 ./app
```

You can also dump a core on failure, as [John Cuppit](https://github.com/jcupitt) said:
```c
g_log_set_always_fatal(
                G_LOG_FLAG_RECURSION |
                G_LOG_FLAG_FATAL |
                G_LOG_LEVEL_ERROR |
                G_LOG_LEVEL_CRITICAL |
                G_LOG_LEVEL_WARNING );
```

Or set the G_DEBUG environment variable:
```
export G_DEBUG=fatal-warnings,fatal-criticals
```

## API

See [godoc reference](https://godoc.org/github.com/h2non/bimg) for detailed API documentation.

## Authors

- [Tomás Aparicio](https://github.com/h2non) - Original author and architect.

## Credits

People who recurrently contributed to improve `bimg` in some way.

- [John Cupitt](https://github.com/jcupitt)
- [Yoan Blanc](https://github.com/greut)
- [Christophe Eblé](https://github.com/chreble)
- [Brant Fitzsimmons](https://github.com/bfitzsimmons)
- [Thomas Meson](https://github.com/zllak)

Thank you!

## License

MIT - Tomas Aparicio

[![views](https://sourcegraph.com/api/repos/github.com/h2non/bimg/.counters/views.svg)](https://sourcegraph.com/github.com/h2non/bimg)


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

Go package for computer vision using OpenCV 3.3+

# GoCV

[![GoCV](https://raw.githubusercontent.com/hybridgroup/gocv/release/images/gocvlogo.jpg)](http://gocv.io/)

[![Go Reference](https://pkg.go.dev/badge/gocv.io/x/gocv.svg)](https://pkg.go.dev/gocv.io/x/gocv)
[![Linux](https://github.com/hybridgroup/gocv/actions/workflows/linux.yml/badge.svg?branch=dev)](https://github.com/hybridgroup/gocv/actions/workflows/linux.yml)
[![macOS](https://github.com/hybridgroup/gocv/actions/workflows/macos.yml/badge.svg?branch=dev)](https://github.com/hybridgroup/gocv/actions/workflows/macos.yml)
[![Windows](https://github.com/hybridgroup/gocv/actions/workflows/windows.yml/badge.svg?branch=dev)](https://github.com/hybridgroup/gocv/actions/workflows/windows.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/hybridgroup/gocv)](https://goreportcard.com/report/github.com/hybridgroup/gocv)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/hybridgroup/gocv/blob/release/LICENSE.txt)

The GoCV package provides Go language bindings for the [OpenCV 4](http://opencv.org/) computer vision library.

The GoCV package supports the latest releases of Go and OpenCV (v4.12.0) on Linux, Docker, macOS, and Windows. Our ongoing mission is help the Go programming language be a "first-class" client compatible with the latest developments in the OpenCV ecosystem.

GoCV supports [CUDA](https://en.wikipedia.org/wiki/CUDA) for hardware acceleration using Nvidia GPUs. Check out the [CUDA README](./cuda/README.md) for more info on how to use GoCV with OpenCV/CUDA.

GoCV also supports [Intel OpenVINO](https://software.intel.com/en-us/openvino-toolkit). Check out the [OpenVINO README](./openvino/README.md) for more info on how to use GoCV with the Intel OpenVINO toolkit.

## How to use

### Hello, video

This example opens a video capture device using device "0", reads frames, and shows the video in a GUI window:

```go
package main

import (
	"gocv.io/x/gocv"
)

func main() {
	webcam, _ := gocv.OpenVideoCapture(0)
	window := gocv.NewWindow("Hello")
	img := gocv.NewMat()

	for {
		webcam.Read(&img)
		window.IMShow(img)
		window.WaitKey(1)
	}
}
```

### Face detect

![GoCV](https://raw.githubusercontent.com/hybridgroup/gocv/release/images/face-detect.jpg)

This is a more complete example that opens a video capture device using device "0". It also uses the CascadeClassifier class to load an external data file containing the classifier data. The program grabs each frame from the video, then uses the classifier to detect faces. If any faces are found, it draws a green rectangle around each one, then displays the video in an output window:

```go
package main

import (
	"fmt"
	"image/color"

	"gocv.io/x/gocv"
)

func main() {
 // set to use a video capture device 0
 deviceID := 0

	// open webcam
	webcam, err := gocv.OpenVideoCapture(deviceID)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer webcam.Close()

	// open display window
	window := gocv.NewWindow("Face Detect")
	defer window.Close()

	// prepare image matrix
	img := gocv.NewMat()
	defer img.Close()

	// color for the rect when faces detected
	blue := color.RGBA{0, 0, 255, 0}

	// load classifier to recognize faces
	classifier := gocv.NewCascadeClassifier()
	defer classifier.Close()

	if !classifier.Load("data/haarcascade_frontalface_default.xml") {
		fmt.Println("Error reading cascade file: data/haarcascade_frontalface_default.xml")
		return
	}

	fmt.Printf("start reading camera device: %v\n", deviceID)
	for {
		if ok := webcam.Read(&img); !ok {
			fmt.Printf("cannot read device %v\n", deviceID)
			return
		}
		if img.Empty() {
			continue
		}

		// detect faces
		rects := classifier.DetectMultiScale(img)
		fmt.Printf("found %d faces\n", len(rects))

		// draw a rectangle around each face on the original image
		for _, r := range rects {
			gocv.Rectangle(&img, r, blue, 3)
		}

		// show the image in the window, and wait 1 millisecond
		window.IMShow(img)
		window.WaitKey(1)
	}
}
```

### More examples

There are examples in the [cmd directory](./cmd) of this repo in the form of various useful command line utilities, such as [capturing an image file](./cmd/saveimage), [streaming mjpeg video](./cmd/mjpeg-streamer), [counting objects that cross a line](./cmd/counter), and [using OpenCV with a DNN for face tracking](./cmd/facedetectYN).

## How to install

To install GoCV, you must first have the matching version of OpenCV installed on your system. The current release of GoCV requires OpenCV 4.12.0.

We have instructions for Linux, macOS, Windows, and other platform options as well.

### Linux

Please see our web site at https://gocv.io/getting-started/linux/

### macOS

Please see our web site at https://gocv.io/getting-started/macos/

### Windows

Please see our web site at https://gocv.io/getting-started/windows/

### Docker

Please see our web site at https://gocv.io/getting-started/docker/

### Android

There is some work in progress for running GoCV on Android using Gomobile. For information on how to install OpenCV/GoCV for Android, please see:
https://gist.github.com/ogero/c19458cf64bd3e91faae85c3ac8874120

See original discussion here:
https://github.com/hybridgroup/gocv/issues/235

## Profiling

Since memory allocations for images in GoCV are done through C based code, the go garbage collector will not clean all resources associated with a `Mat`. As a result, any `Mat` created _must_ be closed to avoid memory leaks.

To ease the detection and repair of the resource leaks, GoCV provides a `Mat` profiler that records when each `Mat` is created and closed. Each time a `Mat` is allocated, the stack trace is added to the profile. When it is closed, the stack trace is removed. See the [runtime/pprof documentation](https://golang.org/pkg/runtime/pprof/#Profile).

In order to include the MatProfile custom profiler, you MUST build or run your application or tests using the `-tags matprofile` build tag. For example:

 go run -tags matprofile cmd/version/main.go

You can get the profile's count at any time using:

```go
gocv.MatProfile.Count()
```

You can display the current entries (the stack traces) with:

```go
var b bytes.Buffer
gocv.MatProfile.WriteTo(&b, 1)
fmt.Print(b.String())
```

This can be very helpful to track down a leak. For example, suppose you have
the following nonsense program:

```go
package main

import (
	"bytes"
	"fmt"

	"gocv.io/x/gocv"
)

func leak() {
	gocv.NewMat()
}

func main() {
	fmt.Printf("initial MatProfile count: %v\n", gocv.MatProfile.Count())
	leak()

	fmt.Printf("final MatProfile count: %v\n", gocv.MatProfile.Count())
	var b bytes.Buffer
	gocv.MatProfile.WriteTo(&b, 1)
	fmt.Print(b.String())
}
```

Running this program produces the following output:

```
initial MatProfile count: 0
final MatProfile count: 1
gocv.io/x/gocv.Mat profile: total 1
1 @ 0x40b936c 0x40b93b7 0x40b94e2 0x40b95af 0x402cd87 0x40558e1
#	0x40b936b	gocv.io/x/gocv.newMat+0x4b	/go/src/gocv.io/x/gocv/core.go:153
#	0x40b93b6	gocv.io/x/gocv.NewMat+0x26	/go/src/gocv.io/x/gocv/core.go:159
#	0x40b94e1	main.leak+0x21			/go/src/github.com/dougnd/gocvprofexample/main.go:11
#	0x40b95ae	main.main+0xae			/go/src/github.com/dougnd/gocvprofexample/main.go:16
#	0x402cd86	runtime.main+0x206		/usr/local/Cellar/go/1.11.1/libexec/src/runtime/proc.go:201
```

We can see that this program would leak memory. As it exited, it had one `Mat` that was never closed. The stack trace points to exactly which line the allocation happened on (line 11, the `gocv.NewMat()`).

Furthermore, if the program is a long running process or if GoCV is being used on a web server, it may be helpful to install the HTTP interface )). For example:

```go
package main

import (
	"net/http"
	_ "net/http/pprof"
	"time"

	"gocv.io/x/gocv"
)

func leak() {
	gocv.NewMat()
}

func main() {
	go func() {
		ticker := time.NewTicker(time.Second)
		for {
			<-ticker.C
			leak()
		}
	}()

	http.ListenAndServe("localhost:6060", nil)
}

```

This will leak a `Mat` once per second. You can see the current profile count and stack traces by going to the installed HTTP debug interface: [http://localhost:6060/debug/pprof/gocv.io/x/gocv.Mat](http://localhost:6060/debug/pprof/gocv.io/x/gocv.Mat?debug=1).

## How to contribute

Please take a look at our [CONTRIBUTING.md](./CONTRIBUTING.md) document to understand our contribution guidelines.

Then check out our [ROADMAP.md](./ROADMAP.md) document to know what to work on next.

## Why this project exists

The [https://github.com/go-opencv/go-opencv](https://github.com/go-opencv/go-opencv) package for Go and OpenCV did not support any version above OpenCV 2.x, and work on adding support for OpenCV 3 had stalled for over a year, mostly due to the complexity of [SWIG](http://swig.org/). That is why we started this project.

The GoCV package uses a C-style wrapper around the OpenCV 4 C++ classes to avoid having to deal with applying SWIG to a huge existing codebase. The mappings are intended to match as closely as possible to the original OpenCV project structure, to make it easier to find things, and to be able to figure out where to add support to GoCV for additional OpenCV image filters, algorithms, and other features.

For example, the [OpenCV `videoio` module](https://github.com/opencv/opencv/tree/master/modules/videoio) wrappers can be found in the GoCV package in the `videoio.*` files.

This package was inspired by the original https://github.com/go-opencv/go-opencv project, the blog post https://medium.com/@peterleyssens/using-opencv-3-from-golang-5510c312a3c and the repo at https://github.com/sensorbee/opencv thank you all!

## License

Licensed under the Apache 2.0 license. Copyright (c) 2017-2026 The Hybrid Group.

Logo generated by GopherizeMe - https://gopherize.me

gocv

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

A lightning fast image processing and resizing library for Go

# <img src="https://raw.githubusercontent.com/davidbyttow/govips/master/assets/SVG/govips.svg" width="90" height="90"> govips

[![GoDoc](https://godoc.org/github.com/davidbyttow/govips?status.svg)](https://pkg.go.dev/mod/github.com/davidbyttow/govips/v2) [![Go Report Card](https://goreportcard.com/badge/github.com/davidbyttow/govips)](https://goreportcard.com/badge/github.com/davidbyttow/govips) ![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/davidbyttow/govips) ![License](https://img.shields.io/badge/license-MIT-blue.svg) [![Build Status](https://github.com/davidbyttow/govips/workflows/build/badge.svg)](https://github.com/davidbyttow/govips/actions) [![Coverage Status](https://img.shields.io/coveralls/github/davidbyttow/govips)](https://coveralls.io/github/davidbyttow/govips?branch=master)

## A lightning fast image processing and resizing library for Go

This package wraps the core functionality of [libvips](https://github.com/libvips/libvips) image processing library by exposing all image operations on first-class types in Go.

Libvips is generally 4-8x faster than other graphics processors such as GraphicsMagick and ImageMagick. Check the benchmark: [Speed and Memory Use](https://github.com/libvips/libvips/wiki/Speed-and-memory-use)

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

## Project Status

govips now includes a built-in code generator (`cmd/vipsgen/`) that uses libvips GObject introspection to auto-generate type-safe Go bindings. This covers 193+ operations across 9 categories (arithmetic, colour, conversion, convolution, create, freqfilt, histogram, morphology, resample), while complex operations like image I/O remain as hand-written bindings for full control.

## Requirements

- [libvips](https://github.com/libvips/libvips) 8.14+
- C compatible compiler such as gcc 4.6+ or clang 3.0+
- Go 1.23+

## Dependencies

### MacOS

Use [homebrew](https://brew.sh/) to install vips and pkg-config:

```bash
brew install vips pkg-config
```

### Windows

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

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

## Installation

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

### MacOS note

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

```bash
export CGO_CFLAGS_ALLOW="-Xpreprocessor"
```

## Examples

Every example below assumes this setup:

```go
package main

import (
	"fmt"
	"os"

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

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

	// ... example code goes here
}
```

### 1. Load an image and export as JPEG

The basics: load from a file, auto-rotate based on EXIF data, and write it back out.

```go
image, err := vips.NewImageFromFile("input.jpg")
if err != nil {
	log.Fatal(err)
}

// Fix orientation from EXIF metadata
if err := image.AutoRotate(); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(vips.NewJpegExportParams())
if err != nil {
	log.Fatal(err)
}
os.WriteFile("output.jpg", buf, 0644)
```

### 2. Resize an image

Scale an image down by 50% using the Lanczos3 kernel (the sharpest option).

```go
image, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

// Scale to 50%
if err := image.Resize(0.5, vips.KernelLanczos3); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(&vips.JpegExportParams{Quality: 85})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("resized.jpg", buf, 0644)
```

### 3. Create a thumbnail with smart crop

`NewThumbnailFromFile` is the fastest way to generate thumbnails. It decodes only the pixels it needs.

```go
// Load and shrink to fit within 200x200, cropping to the most interesting region
image, err := vips.NewThumbnailFromFile("photo.jpg", 200, 200, vips.InterestingAttention)
if err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(&vips.JpegExportParams{Quality: 80})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("thumb.jpg", buf, 0644)
```

### 4. Convert between formats

Load a JPEG and export it as WebP and PNG.

```go
image, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

// Export as WebP (lossy)
webpBuf, _, err := image.ExportWebp(&vips.WebpExportParams{Quality: 75})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("photo.webp", webpBuf, 0644)

// Export as PNG
pngBuf, _, err := image.ExportPng(&vips.PngExportParams{Compression: 6})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("photo.png", pngBuf, 0644)
```

### 5. Crop and extract a region

Pull out a specific rectangle from an image.

```go
image, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

// Extract a 300x300 region starting at (50, 100)
if err := image.ExtractArea(50, 100, 300, 300); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportPng(vips.NewPngExportParams())
if err != nil {
	log.Fatal(err)
}
os.WriteFile("cropped.png", buf, 0644)
```

### 6. Blur and sharpen

Apply a Gaussian blur or sharpen an image.

```go
image, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

// Gaussian blur with sigma=3.0
if err := image.GaussianBlur(3.0); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(vips.NewJpegExportParams())
if err != nil {
	log.Fatal(err)
}
os.WriteFile("blurred.jpg", buf, 0644)

// Or sharpen instead: sigma=1.0, x1=2.0, m2=3.0
image2, _ := vips.NewImageFromFile("photo.jpg")
if err := image2.Sharpen(1.0, 2.0, 3.0); err != nil {
	log.Fatal(err)
}

buf2, _, _ := image2.ExportJpeg(vips.NewJpegExportParams())
os.WriteFile("sharpened.jpg", buf2, 0644)
```

### 7. Rotate and flip

Rotate by fixed angles and flip along an axis.

```go
image, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

// Rotate 90 degrees clockwise
if err := image.Rotate(vips.Angle90); err != nil {
	log.Fatal(err)
}

// Flip horizontally
if err := image.Flip(vips.DirectionHorizontal); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(vips.NewJpegExportParams())
if err != nil {
	log.Fatal(err)
}
os.WriteFile("rotated.jpg", buf, 0644)
```

### 8. Adjust brightness, saturation, and hue

`Modulate` works in the LCH color space. Brightness and saturation are multipliers (1.0 = no change), hue is an angle shift in degrees.

```go
image, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

// Bump brightness by 20%, desaturate by 30%, shift hue by 45 degrees
if err := image.Modulate(1.2, 0.7, 45); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(&vips.JpegExportParams{Quality: 90})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("adjusted.jpg", buf, 0644)
```

### 9. Composite two images (watermark overlay)

Layer one image on top of another using Porter-Duff blending.

```go
base, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

overlay, err := vips.NewImageFromFile("watermark.png")
if err != nil {
	log.Fatal(err)
}

// Place the watermark at position (20, 20) using "over" blending
if err := base.Composite(overlay, vips.BlendModeOver, 20, 20); err != nil {
	log.Fatal(err)
}

buf, _, err := base.ExportJpeg(&vips.JpegExportParams{Quality: 90})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("watermarked.jpg", buf, 0644)
```

### 10. Add a text label

Overlay text directly onto an image.

```go
image, err := vips.NewImageFromFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

err = image.Label(&vips.LabelParams{
	Text: "govips",
	Font: "sans bold 16",
	OffsetX: vips.ValueOf(20),
	OffsetY: vips.ValueOf(20),
	Opacity: 0.8,
	Color: vips.Color{R: 255, G: 255, B: 255},
	Alignment: vips.AlignLow,
	Width: vips.ValueOf(200),
	Height: vips.ValueOf(40),
})
if err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportPng(vips.NewPngExportParams())
if err != nil {
	log.Fatal(err)
}
os.WriteFile("labeled.png", buf, 0644)
```

### 11. Flatten transparency onto a background color

Remove the alpha channel by compositing onto a solid color.

```go
image, err := vips.NewImageFromFile("logo.png")
if err != nil {
	log.Fatal(err)
}

// Flatten alpha onto white
if err := image.Flatten(&vips.Color{R: 255, G: 255, B: 255}); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(&vips.JpegExportParams{Quality: 90})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("flattened.jpg", buf, 0644)
```

### 12. Embed an image in a larger canvas

Center an image inside a larger canvas with a colored background.

```go
image, err := vips.NewImageFromFile("icon.png")
if err != nil {
	log.Fatal(err)
}

w, h := image.Width(), image.Height()

// Center the image inside a 800x600 canvas with a dark background
if err := image.EmbedBackgroundRGBA(
	(800-w)/2, (600-h)/2, 800, 600,
	&vips.ColorRGBA{R: 30, G: 30, B: 30, A: 255},
); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportPng(vips.NewPngExportParams())
if err != nil {
	log.Fatal(err)
}
os.WriteFile("embedded.png", buf, 0644)
```

### 13. Load from a byte buffer and strip metadata

Useful when you're reading images from HTTP requests or databases.

```go
inputBytes, err := os.ReadFile("photo.jpg")
if err != nil {
	log.Fatal(err)
}

image, err := vips.NewImageFromBuffer(inputBytes)
if err != nil {
	log.Fatal(err)
}

// Strip all EXIF/metadata for privacy
if err := image.RemoveMetadata(); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportJpeg(&vips.JpegExportParams{
	Quality: 80,
	StripMetadata: true,
})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("clean.jpg", buf, 0644)
```

### 14. Build a pipeline: thumbnail, sharpen, and export as AVIF

Chain multiple operations together. Each method mutates the image in place, so you can pipeline them naturally.

```go
image, err := vips.NewThumbnailFromFile("photo.jpg", 800, 600, vips.InterestingCentre)
if err != nil {
	log.Fatal(err)
}

if err := image.Sharpen(0.7, 1.0, 2.0); err != nil {
	log.Fatal(err)
}

buf, _, err := image.ExportAvif(&vips.AvifExportParams{
	Quality: 50,
	Effort: 4,
})
if err != nil {
	log.Fatal(err)
}
os.WriteFile("output.avif", buf, 0644)
```

See the _examples/_ folder for more.

## Running tests

```bash
$ make test
```

## Code Generation

The built-in generator lives in `cmd/vipsgen/` and uses libvips GObject introspection to discover operations and their arguments at build time. To regenerate the bindings:

```bash
go generate ./vips/
```

This produces the generated files in `vips/gen_*.{c,h,go}`. You should not need to regenerate unless you are adding support for new libvips operations.

## Memory usage note
### MALLOC_ARENA_MAX
`libvips` uses GLib for memory management, and it brings GLib memory fragmentation
issues to heavily multi-threaded programs. First thing you can try if you noticed
constantly growing RSS usage without Go's sys memory growth is set `MALLOC_ARENA_MAX`:

```
MALLOC_ARENA_MAX=2 application
```

This will reduce GLib memory appetites by reducing the number of malloc arenas
that it can create. By default GLib creates one are per thread, and this would
follow to memory fragmentation.

### Jemalloc
If the arena option doesn't help, you can try replacing the standard allocator with `jemalloc`,
which emphasizes fragmentation avoidance and scalable concurrency support.

To do this, you need to install the `libjemalloc-dev` package. 
And pass the following flags for build command:

```
CGO_CFLAGS="-fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free" CGO_LDFLAGS="-ljemalloc" go build
```


## Contributing

Feel free to file issues or create pull requests. See this [guide on contributing](https://github.com/davidbyttow/govips/blob/master/CONTRIBUTING.md) for more information.

## Credits

Thanks to:

- [John Cupitt](https://github.com/jcupitt) for creating and maintaining libvips
- [Toni Melisma](https://github.com/tonimelisma) for pushing to a 2.x release
- [wix.com](https://wix.com/) for the govips logo and lots of great functionality
- All of our fantastic [contributors](https://github.com/davidbyttow/govips/graphs/contributors)

## License

MIT

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!

 

## Star History

[![Star History Chart](https://api.star-history.com/svg?repos=noelyahan/mergi&type=Timeline)](https://star-history.com/#noelyahan/mergi&Timeline)

### 🔵 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 with Unix socket support
* Image operations: Resize, Rotate, SmartCrop, Blur, Watermark
* Format conversion (JPEG, PNG, BMP, WebP)
* Multiple storage backends (disk, S3, HTTP, Azure, Google Cloud, Oracle, B2, SFTP)
* Fully modular architecture
* S3-compatible API for listing and uploading files
* **Request collapsing** - prevents duplicate processing of identical requests
* **Configurable concurrency limit** - control max concurrent image transformations
* **Automatic lock refresh** - prevents lock expiration during long operations
* **Distributed locking** - Redis-based locking for multi-instance deployments
* Response caching (memory or Redis)
* HTTP Range and Conditional requests support
* Compression (gzip, brotli)
* Environment variables driven configuration
* Custom URL transform parsers using [Tengo](https://github.com/d5/tengo)
* Cloudinary-compatible image transformation and upload API
* Prometheus metrics and debug endpoints
* Automatic memory cleanup during idle periods

See [changelog](CHANGELOG.md) and [documentation](doc/Configuration.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

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.

webp-server

Fast, secure image processing server and Go library, using libvips

# imagor

[![Test Status](https://github.com/cshum/imagor/workflows/test/badge.svg)](https://github.com/cshum/imagor/actions/workflows/test.yml)
[![Codecov](https://img.shields.io/codecov/c/github/cshum/imagor
)](https://codecov.io/gh/cshum/imagor)
[![Docker Hub](https://img.shields.io/badge/docker-shumc/imagor-blue.svg)](https://hub.docker.com/r/shumc/imagor/)
[![Docs](https://img.shields.io/badge/docs-docs.imagor.net-white)](https://docs.imagor.net)

imagor is a fast, secure image processing server and Go library.

imagor uses one of the most efficient image processing library
[libvips](https://github.com/libvips/libvips) with Go binding [vipsgen](https://github.com/cshum/vipsgen). It is typically 4-8x [faster](https://github.com/libvips/libvips/wiki/Speed-and-memory-use) than using the quickest ImageMagick settings.
imagor implements libvips [streaming](https://www.libvips.org/2019/11/29/True-streaming-for-libvips.html) that facilitates parallel processing pipelines, achieving high network throughput.

imagor features a ton of image processing use cases, available as a HTTP server with first-class Docker support. It adopts the [thumbor](https://thumbor.readthedocs.io/en/latest/usage.html#image-endpoint) URL syntax representing a high-performance drop-in replacement.

imagor is a Go library built with speed, security and extensibility in mind. Alongside there is [imagorvideo](https://github.com/cshum/imagorvideo) bringing video thumbnail capability through ffmpeg C bindings.

### Quick Start

```bash
docker run -p 8000:8000 shumc/imagor -imagor-unsafe -imagor-auto-webp
```

Original images:

```
https://raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png
https://raw.githubusercontent.com/cshum/imagor/master/testdata/dancing-banana.gif
https://raw.githubusercontent.com/cshum/imagor/master/testdata/gopher-front.png
```

<img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png" height="100" /> <img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/dancing-banana.gif" height="100" /> <img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/gopher-front.png" height="100" />

Try out the following image URLs:

```
http://localhost:8000/unsafe/fit-in/200x200/filters:fill(white)/https://raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png
http://localhost:8000/unsafe/200x200/smart/filters:fill(white):format(jpeg):quality(80)/https://raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png
http://localhost:8000/unsafe/fit-in/-180x180/10x10/filters:hue(290):saturation(100):fill(yellow)/raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png
http://localhost:8000/unsafe/30x40:100x150/filters:fill(cyan)/raw.githubusercontent.com/cshum/imagor/master/testdata/dancing-banana.gif
http://localhost:8000/unsafe/fit-in/200x150/filters:fill(yellow):watermark(raw.githubusercontent.com/cshum/imagor/master/testdata/gopher-front.png,repeat,bottom,0,40,40)/raw.githubusercontent.com/cshum/imagor/master/testdata/dancing-banana.gif
```

<img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/demo1.jpg" height="100" /> <img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/demo2.jpg" height="100" /> <img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/demo4.jpg" height="100" /> <img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/demo3.gif" height="100" /> <img src="https://raw.githubusercontent.com/cshum/imagor/master/testdata/demo5.gif" height="100" />

> [!NOTE]
> Ready to dive deeper? Check out [Documentation](https://docs.imagor.net/)

imagor

Vector graphics to PDF, SVG or rasterized image

![Canvas](https://raw.githubusercontent.com/tdewolff/canvas/master/resources/title/title.png)

*** **FUNDING REQUIRED** *** **please contact me to support this work**

[![API reference](https://img.shields.io/badge/godoc-reference-5272B4)](https://pkg.go.dev/github.com/tdewolff/canvas?tab=doc) [![User guide](https://img.shields.io/badge/user-guide-5272B4)](https://github.com/tdewolff/canvas/wiki) [![Go Report Card](https://goreportcard.com/badge/github.com/tdewolff/canvas)](https://goreportcard.com/report/github.com/tdewolff/canvas) [![Coverage Status](https://coveralls.io/repos/github/tdewolff/canvas/badge.svg?branch=master)](https://coveralls.io/github/tdewolff/canvas?branch=master)

**[API documentation](https://pkg.go.dev/github.com/tdewolff/canvas?tab=doc)**

**[User guide](https://github.com/tdewolff/canvas/wiki)**

**[Live HTMLCanvas demo](https://tdewolff.github.io/canvas/examples/html-canvas/index.html)**

**[Benchmarks](https://github.com/tdewolff/canvas_benchmarks)**

Canvas is a common vector drawing target that can output SVG, PDF, EPS, raster images (PNG, JPG, GIF, ...), HTML Canvas through WASM, OpenGL, and Gio. It has a wide range of path manipulation functionality such as flattening, stroking and dashing implemented. Additionally, it has a text formatter and embeds and subsets fonts (TTF, OTF, WOFF, WOFF2, or EOT) or converts them to outlines. It can be considered a Cairo or node-canvas alternative in Go. See the example below in Figure 1 for an overview of the functionality.

![Preview](https://raw.githubusercontent.com/tdewolff/canvas/master/resources/preview/preview.png)

**Figure 1**: top-left you can see text being fitted into a box, justified using Donald Knuth's linea breaking algorithm to stretch the spaces between words to fill the whole width. You can observe a variety of styles and text decorations applied, as well as support for LTR/RTL mixing and complex scripts. In the bottom-right the word "stroke" is being stroked and drawn as a path. Top-right we see a LaTeX formula that has been converted to a path. Left of that we see an ellipse showcasing precise dashing, notably the length of e.g. the short dash is equal wherever it is on the curve. Note that the dashes themselves are elliptical arcs as well (thus exactly precise even if magnified greatly). To the right we see a closed polygon of four points being smoothed by cubic Béziers that are smooth along the whole path, and the blue line on the left shows a smoothed open path. On the bottom you can see a rotated rasterized image. The bottom-left shows path boolean operations. The result is equivalent for all renderers (PNG, PDF, SVG, etc.).

### Recent changes
- `RichText.ToText` replaces some parameters by `*TextOptions`, use `rt.ToText(..., &canvas.TextOptions{Indent: indent, LineStretch: lineStretch})` or if `indent` and `lineStretch` are zero use `rt.ToText(..., nil)` for the original result.
- `NewTextBox` replaces some parameters by `*TextOptions`, use `rt.ToText(..., &canvas.TextOptions{Indent: indent, LineStretch: lineStretch})` or if `indent` and `lineStretch` are zero use `rt.ToText(..., nil)` for the original result.
- `Path.Windings` is now `Path.WindingsAt`
- `Path.Crossings` is now `Path.CrossingsAt`
- `Path.Contains` is now `Path.ContainsPoint`
- `Path.Flat` is now `Path.IsFlat`
- `Path.DivideBy` is now `Path.Div`
- `canvas.RGB` and `canvas.RGBA` now accept channel values in [0,1] and not [0,255]
- `RichText.ToText` now consumes the fitted text, leaving remaining content for a next call. If you want to reuse the same content of a `RichText` twice, you need to copy it with `RichText.Copy`.

## State
Whether this library is ready for production environments is up to your own judgment. In general, this library is written thoughtfully and complete, but the scope of this work is so big and the implementation can be quite complex that inevitably it must have a great amount of bugs. Effort was put in writing unit and fuzz tests so that I suspect only special use-cases will stumble into bugs, but coverage is still lacking. As time permits, work is done to flesh-out functionality, find bugs, and optimize code. Optimization could be in execution time / reducing code complexity, reducing memory footprint, or reducing the length of paths from operation.

Execution performance is actually really good, especially the rasterizer is highly optimized with ASM. See for example a comparison of an extreme case in https://github.com/tdewolff/canvas/issues/280#issuecomment-1995990038, where this library is at least twice as fast as existing solutions, and can handle bigger images than the likes of Inkscape and Cairo.

The path intersection code and path boolean operation code is quite complete and fast, and more importantly has a time complexity of O(n log n). It is numerically stable and does not suffer from floating-point precision errors.

Please issue bug reports or feature requests to help this library mature! All help is appreciated. Also see [Wiki - Planning](https://github.com/tdewolff/canvas/wiki/Planning) for an inexhaustive list of ideas and TODOs.

## Features
### General
- Path segment types: MoveTo, LineTo, QuadTo, CubeTo, ArcTo, Close (see [Paths](https://github.com/tdewolff/canvas/wiki/Paths))
- Precise path flattening, stroking, and dashing for all segment types (see papers below)
- Smooth spline generation through points for open and closed paths
- LaTeX to path conversion (native Go and CGO implementations available)
- sRGB compliance (use `SRGBColorSpace`, only available for rasterizer)

### Rendering targets
Paths can be exported as or rendered to:
- Raster images (PNG, GIF, JPEG, TIFF, BMP, WEBP, AVIF, ...)
- PDF
- SVG and SVGZ
- PS and EPS
- HTMLCanvas
- OpenGL
- [Gio](https://gioui.org/)
- [Fyne](https://fyne.io/)

Additionally, it has bindings to be used as renderer for:
- [go-chart](https://github.com/wcharczuk/go-chart)
- [gonum/plot](https://github.com/gonum/plot)

See [Renderers](https://github.com/tdewolff/canvas/wiki/Renderers) for more information.

### Stable path boolean operations
Numerically stable (!) path boolean operations, supporting AND, OR, XOR, NOT, and DIV operations in `O((n+k) log n)`, with `n` the number of segments and `k` the number of intersections. This is very fast and allows handling huge paths. It uses 64-bit floating-point precision for highly accurate computation and employs an additional strategy to ensure numerical stability. In particular:
- Allows paths, subject or clipping, with any number of (overlapping) contours.
- Allows contours with any orientation, clockwise or anticlockwise.
- Contours may be concave or of any shape.
- Contours may self-intersect any number of times.
- Segments may overlap any number of times by any contour.
- Points may be crossed any number of times.
- Segments may be vertical.
- Clipping path is implicitly closed (it makes no sense if it's an open path).
- Subject path may be either open or closed.
- Paths are currently flattened, but supporting Bézier or elliptical arcs is a WIP (not anytime soon).

Numerical stability refers to cases where two segments are extremely close where floating-point precision can alter the computation whether they intersect or not. This is a very difficult problem to solve, and many libraries cannot handle this properly (nor can they handle 'degenerate' paths in general, see the list of properties above). Note that fixed-point precision suffers from the same problem. This library builds on papers from Bentley & Ottmann, de Berg, Martínez, Hobby, and Hershberger (see bibliography below).

Correctness and performance has been tested by drawing all land masses and islands from OpenStreetMap at various scales, which is a huge input (1 GB of compressed Shape files) with extremely degenerate data (many overlapping segments, overlapping points, vertical segments, self-intersections, extremely close intersections, different contour orientations, and so on).

See [Benchmarks](https://github.com/tdewolff/canvas_benchmarks) for a comparison with other libraries.

See [Boolean operations](https://github.com/tdewolff/canvas/wiki/Boolean-operations) for more information.

### Advanced text rendering
High-quality (comparable to TeX) text rendering and line breaking. It uses HarfBuzz for text shaping (native Go and CGO implementations available) and FriBidi for text bidirectionality (native Go and CGO implementations available), and uses Donald Knuth's line breaking algorithm for text layout. This enables the following features:
- Align text left, center, right and justified, including indentation.
- Align text top, middle, bottom in a text box, including setting line spacing.
- Handle any script, eg. latin, cyrillic, devanagari, arabic, hebrew, han, etc.
- Handle left-to-right, right-to-left, or top-to-bottom/bottom-to-top writing systems.
- Mix scripts and fonts in a single line, eg. combine latin and arabic, or bold and regular styles.

Additionally, many font formats are supported (such as TTF, OTF, WOFF, WOFF2, EOT) and rendering can apply a gamma correction of 1.43 for better results. See [Fonts & Text](https://github.com/tdewolff/canvas/wiki/Fonts-&-Text) for more information.

## Examples

**[Amsterdam city centre](https://github.com/tdewolff/canvas/tree/master/examples/amsterdam-centre)**: the centre of Amsterdam is drawn from data loaded from the Open Street Map API.

**[Chile over Europe](https://github.com/tdewolff/canvas/tree/master/examples/chile)**: the size of Chile overlaying Europe in their respective UTM projections.

**[Mauna-Loa CO2 concentration](https://github.com/tdewolff/canvas/tree/master/examples/co2-mauna-loa)**: using data from the Mauna-Loa observatory, carbon dioxide concentrations over time are drawn

**[Text document](https://github.com/tdewolff/canvas/tree/master/examples/text-document)**: an example of a text document using the PDF backend.

**[OpenGL](https://github.com/tdewolff/canvas/tree/master/examples/opengl)**: an example using the OpenGL backend.

**[Gio](https://github.com/tdewolff/canvas/tree/master/examples/gio)**: an example using the Gio backend.

**[Fyne](https://github.com/tdewolff/canvas/tree/master/examples/fyne)**: an example using the Fyne backend.

**[TeX/PGF](https://github.com/tdewolff/canvas/tree/master/examples/tex)**: an example showing the usage of the PGF (TikZ) LaTeX package as renderer in order to generated a PDF using LaTeX.

**[go-chart](https://github.com/tdewolff/canvas/tree/master/examples/go-chart)**: an example using the [go-chart](https://github.com/wcharczuk/go-chart) library, plotting a financial graph.

**[gonum/plot](https://github.com/tdewolff/canvas/tree/master/examples/gonum-plot)**: an example using the [gonum/plot](https://github.com/gonum/plot) library.

**[HTMLCanvas](https://github.com/tdewolff/canvas/tree/master/examples/html-canvas)**: an example using the HTMLCanvas backend, see the [live demo](https://tdewolff.github.io/canvas/examples/html-canvas/index.html).

## Users

This is a non-exhaustive list of library users I've come across. PRs are welcome to extend the list!

- https://github.com/aldernero/gaul (generative art utility library)
- https://github.com/aldernero/sketchy (generative art framework)
- https://github.com/aldernero/spider (spider/radar chart generator)
- https://github.com/BrowserJam/jam001/tree/master/jamierocks (a browser!)
- https://github.com/carbocation/genomisc (genomics tools)
- https://github.com/Dadido3/noita-mapcap (Noita map renderer)
- https://github.com/davidhampgonsalves/Life-Dashboard (show text and emoticons in Kindle)
- https://github.com/davidhampgonsalves/quickdraw (grid of Google Quick Draw Drawings)
- https://github.com/dotaspirit/dotaspirit (draw Dota match data: https://vk.com/rsltdtk)
- https://github.com/engelsjk/go-annular (generative art of annular rings)
- https://github.com/eukarya-inc/reearth-plateauview
- https://github.com/holedaemon/gopster (Topster port)
- https://github.com/html2any/layout (flex layout)
- https://github.com/iand/genster (family trees)
- https://github.com/jansorg/marketplace-stats (reports for JetBrains marketplace)
- https://github.com/kpym/marianne (French republic logo)
- https://github.com/mrmelon54/favicon (Favicon generator)
- https://github.com/namsor/go-qrcode (QR code encoder)
- https://github.com/octohelm/gio-compose (UI component solution for Gio)
- https://github.com/omniskop/vitrum (GUI framework)
- https://github.com/Pavel7004/GraphPlot (plot graphs)
- https://github.com/peteraba/roadmapper (tracking roadmaps: https://rdmp.app/)
- https://github.com/Preston-PLB/choRenderer (render chord charts in propresenter7)
- https://github.com/stv0g/vand (camper/van monitor and control)
- https://github.com/thomscoder/pandora (toy browser)
- https://github.com/uncopied/chirograph (barcode security for art)
- https://github.com/uncopied/go-qrcode (QR code encoder)
- https://github.com/wisepythagoras/gis-utils (GIS utilities)
- https://supertxt.net/git/st-int.html (SuperTXT integrations)
- https://github.com/kenshaw/fv (Command-line font viewer using terminal graphics)

## Articles

- [Numerically stable quadratic formula](https://math.stackexchange.com/questions/866331/numerically-stable-algorithm-for-solving-the-quadratic-equation-when-a-is-very/2007723#2007723)
- [Quadratic Bézier length](https://malczak.linuxpl.com/blog/quadratic-bezier-curve-length/)
- [Bézier spline through open path](https://www.particleincell.com/2012/bezier-splines/)
- [Bézier spline through closed path](https://www.jacos.nl/jacos_html/spline/circular/index.html)
- [Point inclusion in polygon test](https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html)

#### My own

- [Arc length parametrization](https://tacodewolff.nl/posts/20190525-arc-length/)

#### Papers

- [M. Walter, A. Fournier, "Approximate Arc Length Parametrization", Anais do IX SIBGRAPHI (1996), p. 143--150](https://www.visgraf.impa.br/sibgrapi96/trabs/pdf/a14.pdf)
- [T.F. Hain, et al., "Fast, precise flattening of cubic Bézier path and offset curves", Computers & Graphics 29 (2005). p. 656--666](https://doi.org/10.1016/j.cag.2005.08.002)
- [M. Goldapp, "Approximation of circular arcs by cubic polynomials", Computer Aided Geometric Design 8 (1991), p. 227--238](https://doi.org/10.1016/0167-8396%2891%2990007-X)
- [L. Maisonobe, "Drawing and elliptical arc using polylines, quadratic or cubic Bézier curves" (2003)](https://spaceroots.org/documents/ellipse/elliptical-arc.pdf)
- [S.H. Kim and Y.J. Ahn, "An approximation of circular arcs by quartic Bezier curves", Computer-Aided Design 39 (2007, p. 490--493)](https://doi.org/10.1016/j.cad.2007.01.004)
- D.E. Knuth and M.F. Plass, Breaking Paragraphs into Lines, Software: Practice and Experience 11 (1981), p. 1119--1184
- L. Subramaniam, Partition of a non-simple polygon into simple polygons, 2003
- [F. Martínez, et al., "A simple algorithm for Boolean operations on polygons"](https://doi.org/10.1016/j.advengsoft.2013.04.004)
- [J.D. Hobby, "Practical segment intersection with ﬁnite precision output", Computational Geometry (1997)](https://doi.org/10.1016/S0925-7721%2899%2900021-8)
- [J. Hershberger, "Stable snap rounding", Computational Geometry: Theory and Applications, 2013](https://doi.org/10.1016/j.comgeo.2012.02.011)

## License

Released under the [MIT license](LICENSE.md).

Be aware that Fribidi uses the LGPL license.


canvas

Go binding for the cairo graphics library

## go-cairo

### Go binding for the cairo graphics library

Based on Dethe Elza's version https://bitbucket.org/dethe/gocairo
but significantly extended and updated.

Go specific extensions:
* NewSurfaceFromImage(image.Image)
* Surface.GetData() []byte
* Surface.SetData([]byte)
* Surface.GetImage() image.Image
* Surface.SetImage(image.Image)

go-cairo also sports a sub package extimage with image.Image/draw.Image
implementations for 32 bit ARGB and 24 bit RGB color models.

Overview:
* http://go.pkgdoc.org/github.com/ungerik/go-cairo
* http://go.pkgdoc.org/github.com/ungerik/go-cairo/extimage

Missing features
* TextCluster
* FontExtents
* FontFace
* FontOptions
* ScaledFont
* Glyph

### Installation:

Install cairo:

For Debian and Debian derivatives including Ubuntu:

	sudo apt-get install libcairo2-dev

For Fedora:

	sudo yum install cairo-devel

For openSUSE:

	zypper install cairo-devel

For Arch Linux: (also [gcc](https://archlinux.org/packages/core/x86_64/gcc/) and [pkgconf](https://archlinux.org/packages/core/x86_64/pkgconf/) are required)
	
	sudo pacman -S cairo

For MacOS you may get errors finding cairo-pdf.h. To fix this run:

	xcode-select --install
  
Install go-cairo and run go-cairo-example:

	go get github.com/ungerik/go-cairo
	go install github.com/ungerik/go-cairo/go-cairo-example && go-cairo-example


Copyrights: See LICENSE file


[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/ungerik/go-cairo/trend.png)](https://bitdeli.com/free "Bitdeli Badge")



go-cairo

Go bingings for GD
http://bolknote.ru
Evgeny Stepanischev
imbolk@gmail.com

Installation:
    1. install libgd (https://libgd.github.io/)
    2. just run "go get github.com/bolknote/go-gd"

For test you can run sample.go (go run sample.jpg)

go-gd

Generate QR codes with personalized styles, allowing adjustments to color, block size, shape, and icons

# go-qrcode #

[![Go Report Card](https://goreportcard.com/badge/github.com/yeqown/go-qrcode)](https://goreportcard.com/report/github.com/yeqown/go-qrcode) 
[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/yeqown/go-qrcode/v2)
[![Go](https://github.com/yeqown/go-qrcode/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/yeqown/go-qrcode/actions/workflows/go.yml) ![](https://changkun.de/urlstat?mode=github&repo=yeqown/go-qrcode)
![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/yeqown/go-qrcode)
![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/yeqown/go-qrcode)
[![License](https://img.shields.io/badge/license-MIT-green)](./LICENSE)

<img src="./assets/repository_qrcode.png" width="100px" align="right"/>
QR code (abbreviated from Quick Response Code) is the trademark for a type of matrix barcode (or two-dimensional barcode) first designed in 1994 for the automotive industry in Japan. A barcode is a machine-readable optical label that contains information about the item to which it is attached. A QR code uses four standardized encoding modes (numeric, alphanumeric, byte/binary, and kanji) to store data efficiently; extensions may also be used

### Features

- [x] Normally generate QR code across `version 1` to `version 40`.
- [x] Automatically analyze QR version by source text.
- [x] Specifying cell shape allowably with `WithCustomShape`, `WithCircleShape` (default is `rectangle`)
- [x] Specifying output file's format with `WithBuiltinImageEncoder`, `WithCustomImageEncoder` (default is `JPEG`)
- [x] Not only shape of cell, but also color of QR Code background and foreground color.
- [x] `WithLogoImage`, `WithLogoImageFilePNG`, `WithLogoImageFileJPEG` help you add an icon at the central of QR Code.
- [x] `WithBorderWidth` allows to specify any width of 4 sides around the qrcode.
- [x] `WebAssembly` support, check out the [Example](./example/webassembly/README.md) and [README](cmd/wasm/README.md) for more detail.
- [x] support Halftone QR Codes, check out the [Example](./example/with-halftone).
### Install

```sh
go get -u github.com/yeqown/go-qrcode/v2
```

### Quick Start

link to [CODE](./example/main.go)
```go
package main

import (
	"github.com/yeqown/go-qrcode/v2"
	"github.com/yeqown/go-qrcode/writer/standard"
)

func main() {
	qrc, err := qrcode.New("https://github.com/yeqown/go-qrcode")
	if err != nil {
		fmt.Printf("could not generate QRCode: %v", err)
		return
	}
	
	w, err := standard.New("../assets/repo-qrcode.jpeg")
	if err != nil {
		fmt.Printf("standard.New failed: %v", err)
		return
	}
	
	// save file
	if err = qrc.Save(w); err != nil {
		fmt.Printf("could not save image: %v", err)
	}
}
```

### Options

```go
const (
	// EncModeNone mode ...
	EncModeNone encMode = 1 << iota
	// EncModeNumeric mode ...
	EncModeNumeric
	// EncModeAlphanumeric mode ...
	EncModeAlphanumeric
	// EncModeByte mode ...
	EncModeByte
	// EncModeKanji mode ...
	EncModeKanji
)

// WithEncodingMode sets the encoding mode.
func WithEncodingMode(mode encMode) EncodeOption {}

const (
	// ErrorCorrectionLow :Level L: 7% error recovery.
	ErrorCorrectionLow ecLevel = iota + 1
	
	// ErrorCorrectionMedium :Level M: 15% error recovery. Good default choice.
	ErrorCorrectionMedium
	
	// ErrorCorrectionQuart :Level Q: 25% error recovery.
	ErrorCorrectionQuart
	
	// ErrorCorrectionHighest :Level H: 30% error recovery.
	ErrorCorrectionHighest
)

// WithErrorCorrectionLevel sets the error correction level.
func WithErrorCorrectionLevel(ecLevel ecLevel) EncodeOption {}
```

### Samples

> These samples are generated with standard writer, check out [Example](./example/example.go) for more details.

| A | B | C | D |
|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|
| <img src="./assets/example/qrcode_with_bgfgcolor.png" width="160px"> bg-fg color | <img src="./assets/example/qrcode_with_bgtransparent.png" width="160px"> transparent | <img src="./assets/example/qrcode_with_borderwidth.png" width="160px"> border padding | <img src="./assets/example/qrcode_with_circleshape.png" width="160px"> circle shape |
| <img src="./assets/example/qrcode_with_fggradient.png" width="160px"> fg gradient | <img src="./assets/example/qrcode_with_halftone.png" width="160px"> using halftone | <img src="./assets/example/qrcode_with_logo.png" width="160px"> set logo image | <img src="./assets/example/qrcode_with_qrwidth.png" width="160px"> block width |
| <img src="./assets/example/qrcode_with_composableshape.png" width="160px"> custom shape | | | |

 

### Built-in Writers

- [Standard Writer](./writer/standard/README.md), prints QRCode into file and stream
- [Terminal Writer](./writer/terminal/README.md), prints QRCode into terminal
- [File Writer](./writer/file/README.md), prints QRCode into files
- [Compressed Writer](./writer/compressed/README.md), It's generated on a very small scale

Of course, you can also code your own writer, just implement [Writer](./writer/README.md) interface.

### Migrating from v1

`go-qrcode.v2` is a major upgrade from v1, and it is not backward compatible. `v2` redesigned
the API, and it is more flexible and powerful. Features are split into different modules (according to functionality).

- github.com/yeqown/go-qrcode/v2 **_core_** 
- github.com/yeqown/go-qrcode/writer/standard **_writer/imageFile_**
- github.com/yeqown/go-qrcode/writer/terminal **_writer/terminal_**

Check [example/migrating-from-v1](./example/migrating-from-v1/main.go) for more details.

### Links

* [QRCode Tourist](https://www.thonky.com/qr-code-tutorial/)
* [QRCode Wiki](https://en.wikipedia.org/wiki/QR_code)
* [二维码详解 (QRCode analysis in CN-zh)](https://zhuanlan.zhihu.com/p/21463650)
* [数据编码 (How to encode data payload in QRCode in CN-zh)](https://zhuanlan.zhihu.com/p/25432676)

go-qrcode

GPU-accelerated 2D rendering with Canvas-like API, zero CGO (part of [GoGPU](https://github.com/gogpu) pure Go graphics ecosystem)

<h1 align="center">gg</h1>


 2D Graphics Library for Go 
 Pure Go | GPU Accelerated | Production Ready



 <a href="https://github.com/gogpu/gg/actions/workflows/ci.yml"><img src="https://github.com/gogpu/gg/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
 <a href="https://codecov.io/gh/gogpu/gg"><img src="https://codecov.io/gh/gogpu/gg/branch/main/graph/badge.svg" alt="codecov"></a>
 <a href="https://pkg.go.dev/github.com/gogpu/gg"><img src="https://pkg.go.dev/badge/github.com/gogpu/gg.svg" alt="Go Reference"></a>
 <a href="https://goreportcard.com/report/github.com/gogpu/gg"><img src="https://goreportcard.com/badge/github.com/gogpu/gg" alt="Go Report Card"></a>
 <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License"></a>
 <a href="https://github.com/gogpu/gg/releases"><img src="https://img.shields.io/github/v/release/gogpu/gg" alt="Latest Release"></a>
 <a href="https://github.com/gogpu/gg"><img src="https://img.shields.io/badge/Go-1.25+-00ADD8?logo=go" alt="Go Version"></a>



 Part of the <a href="https://github.com/gogpu">GoGPU</a> ecosystem


---

## Overview

**gg** is a 2D graphics library for Go designed to power IDEs, browsers, and graphics-intensive applications. Built with modern patterns inspired by [vello](https://github.com/linebender/vello) and [tiny-skia](https://github.com/RazrFalcon/tiny-skia), it delivers production-grade rendering with zero CGO dependencies.


 <video src="https://github.com/user-attachments/assets/34243cff-5434-411c-a17c-3e52a80f1d57" width="100%" autoplay loop muted playsinline>
 Six-Tier GPU Rendering: SDF shapes, convex polygons, stencil+cover paths, MSDF text, Vello compute pipeline, glyph mask cache
 </video>
 
 Six-tier GPU rendering: SDF shapes, convex polygons, stencil+cover paths, MSDF text, Vello compute, and glyph mask cache.
 Pure Go, Vulkan/DX12/GLES backends, zero CGO. (<a href="examples/gogpu_integration/">source</a>)


### Key Features

| Category | Capabilities |
|----------|--------------|
| **Rendering** | Immediate and retained mode, six-tier GPU acceleration (SDF, Convex, Stencil+Cover, MSDF Text, Compute, Glyph Mask), Vello analytic AA, GPU scissor rect clipping, CPU fallback |
| **Shapes** | Rectangles, circles, ellipses, arcs, bezier curves, polygons, stars |
| **Text** | TrueType fonts, MSDF + glyph mask dual-strategy rendering, TextMode auto-selection, DPI-aware HiDPI text, ClearType LCD subpixel rendering, font hinting (auto-hinter), transform-aware CPU text (scale/rotate/shear), glyph outline caching, emoji support, bidirectional text, HarfBuzz shaping |
| **Compositing** | 29 blend modes (Porter-Duff, Advanced, HSL), layer isolation, alpha masks (per-shape, per-layer, luminance, post-process) |
| **Images** | 7 pixel formats, PNG/JPEG/WebP I/O, mipmaps, affine transforms |
| **SVG** | Full SVG renderer (`gg/svg`): parse + render SVG XML with color override for theming, SVG path data parser (`ParseSVGPath`), transform-aware `FillPath`/`StrokePath` |
| **Vector Export** | Recording system with PDF and SVG backends |
| **Rasterizer** | Smart per-path algorithm selection (scanline, 4×4 tiles, 16×16 tiles, SDF, compute), text-aware area-based routing |
| **Performance** | Tile-based parallel rendering, LRU caching |

---

## Installation

```bash
go get github.com/gogpu/gg
```

**Requirements:** Go 1.25+

---

## Quick Start

```go
package main

import (
 "github.com/gogpu/gg"
 "github.com/gogpu/gg/text"
)

func main() {
 // Create drawing context
 dc := gg.NewContext(512, 512)
 defer dc.Close()

 dc.ClearWithColor(gg.White)

 // Draw shapes
 dc.SetHexColor("#3498db")
 dc.DrawCircle(256, 256, 100)
 dc.Fill()

 // Render text
 source, _ := text.NewFontSourceFromFile("arial.ttf")
 defer source.Close()

 dc.SetFont(source.Face(32))
 dc.SetColor(gg.Black)
 dc.DrawString("Hello, GoGPU!", 180, 260)

 dc.SavePNG("output.png")
}
```

---

## Rendering

### Software Rendering (Default)

The CPU rasterizer automatically selects the optimal algorithm per-path:

| Algorithm | Tiles | Best For |
|-----------|-------|----------|
| **AnalyticFiller** (scanline) | — | Simple paths, small shapes (< 32px) |
| **SparseStrips** | 4×4 | Complex paths, CPU/SIMD workloads |
| **TileCompute** | 16×16 | Extreme complexity (10K+ segments) |

```go
dc := gg.NewContext(800, 600)
defer dc.Close()

// Auto-selection (default) — optimal algorithm per-path
dc.DrawCircle(400, 300, 100)
dc.Fill()

// Force specific algorithm for benchmarking
dc.SetRasterizerMode(gg.RasterizerSparseStrips)
```

### GPU Acceleration (Optional)

gg supports optional GPU acceleration through the `GPUAccelerator` interface with
a six-tier rendering pipeline:

| Tier | Method | Best For |
|------|--------|----------|
| **SDF** | Signed Distance Field | Circles, ellipses, rectangles, rounded rects |
| **Convex** | Direct vertex emission | Convex polygons, single draw call |
| **Stencil+Cover** | Fan tessellation + stencil buffer | Arbitrary complex paths, EvenOdd/NonZero fill |
| **MSDF Text** | Multi-channel Signed Distance Field | Dynamic/animated text, resolution-independent |
| **Compute** | 9-stage Vello compute pipeline | Full scenes with many paths (GPU parallel rasterization) |
| **Glyph Mask** | CPU-rasterized R8 alpha atlas | Static UI text ≤48px, pixel-perfect quality |

Tiers 1–4, 6 use a render-pass pipeline; Tier 5 uses compute shaders dispatched
via `PipelineMode` (Auto/RenderPass/Compute). Text auto-selection routes horizontal
text ≤48px to Glyph Mask (Skia/Chrome pattern), else MSDF.

When no GPU is registered, rendering uses the high-quality CPU rasterizer (default).

```go
import (
 "github.com/gogpu/gg"
 _ "github.com/gogpu/gg/gpu" // opt-in GPU acceleration
)

func main() {
 // GPU automatically used when available, falls back to CPU
 dc := gg.NewContext(800, 600)
 defer dc.Close()

 dc.DrawCircle(400, 300, 100)
 dc.Fill() // tries GPU first, falls back to CPU transparently
}
```

For zero-copy rendering directly to a GPU surface (e.g., in a gogpu window),
use [`ggcanvas.Canvas.RenderDirect`](integration/ggcanvas/) — see the
[gogpu integration example](examples/gogpu_integration/). The example uses
event-driven rendering with `AnimationToken` for power-efficient VSync (0% CPU when idle).

### Custom Pixmap

```go
// Use existing pixmap
pm := gg.NewPixmap(800, 600)
dc := gg.NewContext(800, 600, gg.WithPixmap(pm))
```

---

## Architecture

```
 gg (Public API)
 │
 ┌───────────────────┼───────────────────┐
 │ │ │
 Immediate Mode Retained Mode Resources
 (Context API) (Scene Graph) (Images, Fonts)
 │ │ │
 └───────────────────┼───────────────────┘
 │
 ┌──────────────┴──────────────┐
 │ │
 CPU Raster GPUAccelerator
 (always available) (opt-in via gg/gpu)
 │ │
 internal/raster ┌──────────┼──────────┐
 │ │ │
 Render Pass MSDF Text Compute
 (Tiers 1-3) (Tier 4) (Tier 5)
```

### Rendering Structure

| Component | Location | Description |
|-----------|----------|-------------|
| **CPU Raster** | `internal/raster/` | Scanline analytic AA (hybrid: Vello coverage + Skia/tiny-skia edge infrastructure) |
| **Tile Rasterizers** | `internal/gpu/` (4×4), `internal/gpu/tilecompute/` (16×16) | SparseStrips + TileCompute, both ported from Vello |
| **GPU Accelerator** | `internal/gpu` | Six-tier GPU pipeline (SDF, Convex, Stencil+Cover, MSDF Text, Compute, Glyph Mask) |
| **GPU + Tiles** | `gpu/` | Opt-in via `import _ "github.com/gogpu/gg/gpu"` (GPU + tile rasterizers) |
| **Tiles Only** | `raster/` | Opt-in via `import _ "github.com/gogpu/gg/raster"` (CPU-only tiles) |
| **Software** | Root `gg` package | Default CPU renderer with smart algorithm selection |

---

## Core APIs

### Immediate Mode (Context)

Canvas-style drawing with transformation stack:

```go
dc := gg.NewContext(800, 600)
defer dc.Close()

// Transforms
dc.Push()
dc.Translate(400, 300)
dc.Rotate(math.Pi / 4)
dc.DrawRectangle(-50, -50, 100, 100)
dc.SetRGB(0.2, 0.5, 0.8)
dc.Fill()
dc.Pop()

// Bezier paths
dc.MoveTo(100, 100)
dc.QuadraticTo(200, 50, 300, 100)
dc.CubicTo(350, 150, 350, 250, 300, 300)
dc.SetLineWidth(3)
dc.Stroke()
```

### Fluent Path Builder

Type-safe path construction with method chaining:

```go
path := gg.BuildPath().
 MoveTo(100, 100).
 LineTo(200, 100).
 QuadTo(250, 150, 200, 200).
 CubicTo(150, 250, 100, 250, 50, 200).
 Close().
 Circle(300, 150, 50).
 Star(400, 150, 40, 20, 5).
 Build()

dc.SetPath(path)
dc.Fill()
```

### Retained Mode (Scene Graph)

GPU-optimized scene graph for complex applications:

```go
import "github.com/gogpu/gg/render"

s := render.NewScene()

s.SetFillColor(color.RGBA{R: 255, A: 200})
s.Circle(150, 200, 100)
s.Fill()

s.SetFillColor(color.RGBA{B: 255, A: 200})
s.Circle(250, 200, 100)
s.Fill()

renderer := render.NewSoftwareRenderer()
target := render.NewPixmapTarget(800, 600)
renderer.Render(target, s)
```

### Text Rendering

Full Unicode support with font fallback and optional HarfBuzz-level shaping:

```go
// Font composition
mainFont, _ := text.NewFontSourceFromFile("Roboto.ttf")
emojiFont, _ := text.NewFontSourceFromFile("NotoEmoji.ttf")
defer mainFont.Close()
defer emojiFont.Close()

multiFace, _ := text.NewMultiFace(
 mainFont.Face(24),
 text.NewFilteredFace(emojiFont.Face(24), text.RangeEmoji),
)

dc.SetFont(multiFace)
dc.DrawString("Hello World! Nice day!", 50, 100)

// Optional: enable HarfBuzz shaping for ligatures, kerning, complex scripts
shaper := text.NewGoTextShaper()
text.SetShaper(shaper)
defer text.SetShaper(nil)

// Text layout with wrapping
opts := text.LayoutOptions{
 MaxWidth: 400,
 WrapMode: text.WrapWordChar,
 Alignment: text.AlignCenter,
}
layout := text.LayoutText("Long text...", face, opts)
```

#### Transform-Aware Text

Text rendering respects the full transformation matrix (scale, rotation, shear):

```go
dc.SetFont(source.Face(24))
dc.SetRGB(0, 0, 0)

// Scaled text — rendered at device resolution (no pixelation)
dc.Push()
dc.Scale(2, 2)
dc.DrawString("2x Scale", 50, 50)
dc.Pop()

// Rotated text — glyph outlines converted to vector paths
dc.Push()
dc.Translate(200, 200)
dc.Rotate(math.Pi / 6) // 30 degrees
dc.DrawString("Rotated", 0, 0)
dc.Pop()
```

Text rendering strategy is selectable per-Context via `SetTextMode()`:

| Mode | Strategy | Best for |
|------|----------|----------|
| `TextModeAuto` | Auto-select (default) | General use |
| `TextModeMSDF` | GPU MSDF atlas | Games, animations, real-time scaling |
| `TextModeVector` | Glyph outlines as paths | UI labels, quality-critical text |
| `TextModeBitmap` | CPU bitmap rasterization | PNG/PDF export, static text |

The CPU text pipeline uses a three-tier strategy (modeled after Skia/Cairo/Vello):
translation-only → bitmap, uniform scale ≤256px → bitmap at device size,
everything else → glyph outlines as vector paths with cached outlines via `GlyphCache`.

### Color Emoji

Full color emoji support with CBDT/CBLC (bitmap) and COLR/CPAL (vector) formats:


 <img src="docs/images/colr_palette.png" alt="COLR Color Palette" width="512">
 
 175 colors from Segoe UI Emoji COLR/CPAL palette


```go
// Extract color emoji from font
extractor, _ := emoji.NewCBDTExtractor(cbdtData, cblcData)
glyph, _ := extractor.GetGlyph(glyphID, ppem)
img, _ := png.Decode(bytes.NewReader(glyph.Data))

// Parse COLR/CPAL vector layers
parser, _ := emoji.NewCOLRParser(colrData, cpalData)
glyph, _ := parser.GetGlyph(glyphID, paletteIndex)
for _, layer := range glyph.Layers {
 // Render each layer with layer.Color
}
```

See [`examples/color_emoji/`](examples/color_emoji/) for a complete example.

### Layer Compositing

29 blend modes with isolated layers:

```go
dc.PushLayer(gg.BlendOverlay, 0.7)

dc.SetRGB(1, 0, 0)
dc.DrawCircle(150, 200, 100)
dc.Fill()

dc.SetRGB(0, 0, 1)
dc.DrawCircle(250, 200, 100)
dc.Fill()

dc.PopLayer()
```

### Alpha Masks

Per-shape masking — each draw individually masked:

```go
// Create a circular mask
dc.DrawCircle(200, 200, 100)
mask := dc.AsMask() // capture path as mask (before Fill!)
dc.ClearPath()

// Apply mask: only the circle area is visible
dc.SetMask(mask)
dc.SetRGB(0, 0, 1)
dc.DrawRectangle(0, 0, 400, 400)
dc.Fill() // blue only inside the circle
```

Per-layer masking — mask an entire group of draws:

```go
mask := gg.NewMask(400, 400)
// ... fill mask with desired shape ...

dc.PushMaskLayer(mask)
dc.DrawCircle(100, 100, 50)
dc.Fill()
dc.DrawRectangle(200, 200, 80, 80)
dc.Fill()
dc.PopLayer() // entire layer masked, then composited
```

### Recording & Vector Export

Record drawing operations and export to PDF or SVG:

```go
import (
 "github.com/gogpu/gg/recording"
 _ "github.com/gogpu/gg-pdf" // Register PDF backend
 _ "github.com/gogpu/gg-svg" // Register SVG backend
)

// Create recorder
rec := recording.NewRecorder(800, 600)

// Draw using familiar API
rec.SetColor(gg.Blue)
rec.DrawCircle(400, 300, 100)
rec.Fill()

// Finish recording and play back to a raster backend
r := rec.FinishRecording()
backend := raster.NewBackend()
r.Playback(backend)
backend.SaveToFile("output.png")
```

---

## Why "Context" Instead of "Canvas"?

The drawing type is named `Context` following industry conventions:

| Library | Drawing Type |
|---------|-------------|
| HTML5 Canvas | `CanvasRenderingContext2D` |
| Cairo | `cairo_t` (context) |
| Apple CoreGraphics | `CGContext` |
| piet (Rust) | `RenderContext` |

In HTML5, Canvas is the element while **Context** performs drawing (`canvas.getContext("2d")`). The `Context` contains drawing state and provides the drawing API.

**Convention:** `dc` for drawing context, `ctx` for `context.Context`:

```go
dc := gg.NewContext(512, 512) // dc = drawing context
```

---

## Performance

| Operation | Time | Notes |
|-----------|------|-------|
| sRGB to Linear | 0.16ns | 260x faster than math.Pow |
| LayerCache.Get | 90ns | Thread-safe LRU |
| DirtyRegion.Mark | 10.9ns | Lock-free atomic |
| MSDF lookup | <10ns | Zero-allocation |
| Path iteration | 23ns | SOA Iterate(), 0 allocs |
| FillRect | 77µs | **0 allocs** (zero-alloc pipeline) |
| FillCircle r100 | 2ms | **0 allocs** (zero-alloc pipeline) |
| Gradient ColorAt | 33ns | 0 allocs (pre-sorted stops) |

---

## Ecosystem

**gg** is part of the [GoGPU](https://github.com/gogpu) ecosystem.

| Project | Description |
|---------|-------------|
| [gogpu/gogpu](https://github.com/gogpu/gogpu) | GPU framework with windowing and input |
| [gogpu/wgpu](https://github.com/gogpu/wgpu) | Pure Go WebGPU implementation |
| [gogpu/naga](https://github.com/gogpu/naga) | Shader compiler (WGSL to SPIR-V, MSL, GLSL) |
| **gogpu/gg** | **2D graphics (this repo)** |
| [gogpu/gg-pdf](https://github.com/gogpu/gg-pdf) | PDF export backend for recording |
| [gogpu/gg-svg](https://github.com/gogpu/gg-svg) | SVG export backend for recording |
| [gogpu/ui](https://github.com/gogpu/ui) | GUI toolkit (planned) |

---

## Documentation

- **[ARCHITECTURE.md](docs/ARCHITECTURE.md)** — System architecture
- **[ROADMAP.md](ROADMAP.md)** — Development milestones
- **[CHANGELOG.md](CHANGELOG.md)** — Release notes
- **[CONTRIBUTING.md](CONTRIBUTING.md)** — Contribution guidelines
- **[pkg.go.dev](https://pkg.go.dev/github.com/gogpu/gg)** — API reference

### Articles

- [GoGPU: From Idea to 100K Lines in Two Weeks](https://dev.to/kolkov/gogpu-from-idea-to-100k-lines-in-two-weeks-building-gos-gpu-ecosystem-3b2)
- [Pure Go 2D Graphics Library with GPU Acceleration](https://dev.to/kolkov/pure-go-2d-graphics-library-with-gpu-acceleration-introducing-gogpugg-538h)
- [GoGPU Announcement](https://dev.to/kolkov/gogpu-a-pure-go-graphics-library-for-gpu-programming-2j5d)

---

## Contributing

Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

**Priority areas:**
- API feedback and testing
- Examples and documentation
- Performance benchmarks
- Cross-platform testing

---

## License

MIT License — see [LICENSE](LICENSE) for details.

---


 gg — 2D Graphics for Go

gogpu/gg

Screenshoting webpages using go and headless chrome on command line

<h1 align="center">
 
 gowitness
 
 
</h1>

<h4 align="center">A golang, web screenshot utility using Chrome Headless.</h4>

 <a href="https://twitter.com/leonjza"><img src="https://img.shields.io/badge/twitter-%40leonjza-blue.svg" alt="@leonjza" height="18"></a>
 <a href="https://goreportcard.com/report/github.com/sensepost/gowitness"><img src="https://goreportcard.com/badge/github.com/sensepost/gowitness" alt="Go Report Card" height="18"></a>
 <a href="https://github.com/sensepost/gowitness/actions/workflows/docker.yml"><img alt="Docker build & Push" src="https://github.com/sensepost/gowitness/actions/workflows/docker.yml/badge.svg"></a>

 

## introduction

`gowitness` is a website screenshot utility written in Golang, that uses Chrome Headless to generate screenshots of web interfaces using the command line, with a handy report viewer to process results. Both Linux and macOS is supported, with Windows support mostly working.

## features

The main goal of `gowitness` is to take website screenshots (**and do that well!**), while optionally saving any information it gathered along the way. That said, a short list of features include:

- Take website screenshots, obviously..., but fast and accurate!
- Scan a list of URLs, CIDRs, Nmap Results, Nessus Results and more.
- Ability to grab and save data (i.e., a request log, console logs, headers, cookies, etc.)
- Write data to many formats (sqlite database, jsonlines, csv, etc.)
- An epic web-based results viewer (if you saved data to SQLite) including a fully featured API!
- And many, many more!

## quick start

There are a few ways to get gowitness, the simplest (assuming your `$GOBIN` path is in your shell `$PATH`) will be to use `go install`:

```text
go install github.com/sensepost/gowitness@latest
```

Otherwise, grab a platform specific release binary or compile from source. Then, scan your first target writing the results to a SQLite database and the screenshot to `./screenshots` with:

```text
gowitness scan single --url "https://sensepost.com" --write-db
```

There are many, *many* flags and scan types in `gowitness`. Just add `-h` anywhere and read all about it!

## documentation

For advanced installation information and other documentation, please refer to the wiki [here](https://github.com/sensepost/gowitness/wiki).

## screenshots

![gallery](images/gowitness-gallery.png)

![detail](images/gowitness-detail.png)

![terminal](images/gowitness-terminal.png)

## credits

`gowitness` would not have been possible without some of [these amazing projects](./go.mod): [chi](https://github.com/go-chi/chi), [chromedp](https://github.com/chromedp/chromedp), [go-rod](https://github.com/go-rod/rod), [cobra](https://github.com/spf13/cobra), [gorm](https://github.com/go-gorm/gorm), [glamour](https://github.com/charmbracelet/glamour), [go-nmap](https://github.com/lair-framework/go-nmap), [wappalyzergo](https://github.com/projectdiscovery/wappalyzergo), [goimagehash](https://github.com/corona10/goimagehash).

## license

`gowitness` is licensed under a [GNU General Public v3 License](https://www.gnu.org/licenses/gpl-3.0.en.html). Permissions beyond the scope of this license may be available at <http://sensepost.com/contact/>.

gowitness

# gridder [![Build Status](https://travis-ci.com/shomali11/gridder.svg?branch=master)](https://travis-ci.com/shomali11/gridder) [![Go Report Card](https://goreportcard.com/badge/github.com/shomali11/gridder)](https://goreportcard.com/report/github.com/shomali11/gridder) [![GoDoc](https://godoc.org/github.com/shomali11/gridder?status.svg)](https://godoc.org/github.com/shomali11/gridder) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Built on top of Go Graphics [github.com/fogleman/gg](https://github.com/fogleman/gg) with the idea to simplify visualizing Grids using 2D Graphics.

## Dependencies

- `gg` [github.com/fogleman/gg](https://github.com/fogleman/gg)

# Install

```
go get github.com/shomali11/gridder
```

# Examples

## Example 1

Exploring the `GridConfig` configuration object. The `Rows` and `Columns` represent the rows and columns of the grid you wish to visualize. You can customize the grid by playing various options from style, color and width.

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{Name: "example1.png"}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 8,
		MarginWidth: 0,
		LineDashes: 0,
		LineStrokeWidth: 2,
		BorderDashes: 0,
		BorderStrokeWidth: 10,
		LineColor: color.Gray{},
		BorderColor: color.RGBA{B: 255, A: 255},
		BackgroundColor: color.White,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	grid.SavePNG()
}
```

![Result](examples/example1/example1.png)


## Example 2

Exploring the `ImageConfig` configuration object. This defines the image that will be generated. You can customize the `Width` and `Height` to generate larger images.

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example2.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 4,
		MarginWidth: 20,
		LineDashes: 10,
		LineStrokeWidth: 2,
		BorderDashes: 20,
		BorderStrokeWidth: 4,
		LineColor: color.RGBA{R: 255 / 2, A: 255},
		BorderColor: color.RGBA{B: 255 / 2, A: 255},
		BackgroundColor: color.RGBA{G: 255 / 2, A: 255},
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	grid.SavePNG()
}
```

![Result](examples/example2/example2.png)


## Example 3

Using `PaintCell` to paint a cell by the grid's row and column

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example3.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 4,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	grid.PaintCell(1, 2, color.Black)
	grid.SavePNG()
}
```

![Result](examples/example3/example3.png)


## Example 4

Using `DrawRectangle` to draw rectangles in cells with various stylistic properties

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example4.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 4,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	grid.DrawRectangle(0, 0, gridder.RectangleConfig{Width: 60, Height: 60, Color: color.Black, Stroke: true, Rotate: 45})
	grid.DrawRectangle(3, 0, gridder.RectangleConfig{Width: 60, Height: 60, Color: color.Black, Stroke: true, Rotate: 45, Dashes: 10})
	grid.DrawRectangle(0, 3, gridder.RectangleConfig{Width: 60, Height: 60, Color: color.Black, Stroke: true, StrokeWidth: 25})
	grid.DrawRectangle(2, 1, gridder.RectangleConfig{Width: 180, Height: 180, Color: color.RGBA{R: 255 / 2, A: 255 / 2}})
	grid.DrawRectangle(3, 3, gridder.RectangleConfig{Width: 60, Height: 60, Color: color.Black, Stroke: false})
	grid.SavePNG()
}
```

![Result](examples/example4/example4.png)


## Example 5

Using `DrawCircle` to draw circles in cells with various stylistic properties

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example5.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 4,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	grid.DrawCircle(0, 0, gridder.CircleConfig{Radius: 30, Color: color.Black, Stroke: true})
	grid.DrawCircle(3, 0, gridder.CircleConfig{Radius: 30, Color: color.Black, Stroke: true, Dashes: 10})
	grid.DrawCircle(0, 3, gridder.CircleConfig{Radius: 30, Color: color.Black, Stroke: true, StrokeWidth: 25})
	grid.DrawCircle(2, 1, gridder.CircleConfig{Radius: 90, Color: color.RGBA{R: 255 / 2, A: 255 / 2}})
	grid.DrawCircle(3, 3, gridder.CircleConfig{Radius: 30, Color: color.Black, Stroke: false})
	grid.SavePNG()
}
```

![Result](examples/example5/example5.png)


## Example 6

Using `DrawLine` to draw lines in cells with various stylistic properties

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example6.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 4,
		MarginWidth: 30,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	grid.DrawLine(0, 0, gridder.LineConfig{Length: 60, Color: color.Black, Dashes: 0})
	grid.DrawLine(0, 0, gridder.LineConfig{Length: 60, Color: color.Black, Dashes: 0, Rotate: 90})
	grid.DrawLine(0, 3, gridder.LineConfig{Length: 60, Color: color.Black, Dashes: 0, StrokeWidth: 25})
	grid.DrawLine(2, 1, gridder.LineConfig{Length: 90, Color: color.RGBA{R: 255 / 2, A: 255 / 2}, Rotate: 45})
	grid.DrawLine(2, 1, gridder.LineConfig{Length: 90, Color: color.RGBA{R: 255 / 2, A: 255 / 2}, Rotate: 135})
	grid.DrawLine(3, 3, gridder.LineConfig{Length: 60, Color: color.Black, Dashes: 5})
	grid.SavePNG()
}
```

![Result](examples/example6/example6.png)


## Example 7

Using `DrawPath` to draw a path between two cells with various stylistic properties

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example7.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 4,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	grid.DrawPath(0, 0, 1, 1, gridder.PathConfig{Dashes: 0, StrokeWidth: 10, Color: color.Black})
	grid.DrawPath(1, 1, 2, 1, gridder.PathConfig{Dashes: 5, StrokeWidth: 1, Color: color.Black})
	grid.DrawPath(2, 1, 3, 1, gridder.PathConfig{Dashes: 8, StrokeWidth: 1, Color: color.Black})
	grid.DrawPath(3, 1, 3, 2, gridder.PathConfig{Dashes: 0, StrokeWidth: 1, Color: color.Black})
	grid.SavePNG()
}
```

![Result](examples/example7/example7.png)


## Example 8

Using `DrawString` to draw a string in a cell with various stylistic properties

```go
package main

import (
	"image/color"
	"log"

	"github.com/golang/freetype/truetype"
	"github.com/shomali11/gridder"
	"golang.org/x/image/font/gofont/goregular"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example8.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 4,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	font, err := truetype.Parse(goregular.TTF)
	if err != nil {
		log.Fatal(err)
	}

	fontFace1 := truetype.NewFace(font, &truetype.Options{Size: 24})
	fontFace2 := truetype.NewFace(font, &truetype.Options{Size: 35})

	grid.DrawString(0, 0, "Hello!", fontFace1)
	grid.DrawString(1, 1, "Hello!", fontFace1, gridder.StringConfig{Rotate: 45})
	grid.DrawString(2, 2, "Hello!", fontFace2, gridder.StringConfig{Color: color.RGBA{B: 255 / 2, A: 255 / 2}})
	grid.SavePNG()
}
```

![Result](examples/example8/example8.png)


## Example 9

Combining multiple features to draw the shortest path on a grid

```go
package main

import (
	"image/color"
	"log"

	"github.com/golang/freetype/truetype"
	"github.com/shomali11/gridder"
	"golang.org/x/image/font/gofont/goregular"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 2000,
		Height: 1000,
		Name: "example9.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 4,
		Columns: 8,
		MarginWidth: 32,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 20,
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	font, err := truetype.Parse(goregular.TTF)
	if err != nil {
		log.Fatal(err)
	}

	fontFace := truetype.NewFace(font, &truetype.Options{Size: 48})

	lineConfig := gridder.PathConfig{Dashes: 10}
	circleConfig := gridder.CircleConfig{Color: color.Gray{}, Radius: 10}

	grid.PaintCell(1, 2, color.NRGBA{R: 0, G: 0, B: 0, A: 255 / 2})
	grid.DrawString(1, 2, "Block", fontFace)

	grid.DrawCircle(0, 0, gridder.CircleConfig{Color: color.NRGBA{R: 255 / 2, G: 0, B: 0, A: 255 / 2}, Radius: 60})
	grid.DrawPath(0, 0, 1, 1, lineConfig)
	grid.DrawCircle(1, 1, circleConfig)
	grid.DrawPath(1, 1, 2, 2, lineConfig)
	grid.DrawCircle(2, 2, circleConfig)
	grid.DrawPath(2, 2, 2, 3, lineConfig)
	grid.DrawCircle(2, 3, circleConfig)
	grid.DrawPath(2, 3, 2, 4, lineConfig)
	grid.DrawCircle(2, 4, circleConfig)
	grid.DrawPath(2, 4, 2, 5, lineConfig)
	grid.DrawCircle(2, 5, circleConfig)
	grid.DrawPath(2, 5, 2, 6, lineConfig)
	grid.DrawCircle(2, 6, circleConfig)
	grid.DrawPath(2, 6, 3, 7, lineConfig)
	grid.DrawCircle(3, 7, gridder.CircleConfig{Color: color.NRGBA{R: 0, G: 255 / 2, B: 0, A: 255 / 2}, Radius: 60})

	grid.SavePNG()
}
```

![Result](examples/example9/example9.png)


## Example 10

Combining multiple features to draw a Bingo card

```go
package main

import (
	"image/color"
	"log"

	"github.com/golang/freetype/truetype"
	"github.com/shomali11/gridder"
	"golang.org/x/image/font/gofont/goregular"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 1000,
		Height: 1200,
		Name: "example10.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 6,
		Columns: 5,
		MarginWidth: 32,
		LineStrokeWidth: 2,
		BackgroundColor: color.RGBA{R: 135, G: 211, B: 124, A: 255},
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	font, err := truetype.Parse(goregular.TTF)
	if err != nil {
		log.Fatal(err)
	}

	headerFontFace := truetype.NewFace(font, &truetype.Options{Size: 100})
	valueFontFace := truetype.NewFace(font, &truetype.Options{Size: 50})

	headers := []string{"B", "I", "N", "G", "O"}
	values := [][]string{
		{"10", "22", "41", "53", "71"},
		{"66", "20", "40", "50", "2"},
		{"14", "26", "FREE", "52", "69"},
		{"15", "29", "37", "51", "65"},
		{"17", "6", "35", "55", "64"},
	}

	circleConfig := gridder.CircleConfig{Radius: 60, Color: color.White}
	for i, header := range headers {
		grid.DrawCircle(0, i, circleConfig)
		grid.DrawString(0, i, header, headerFontFace)
	}

	for row := range values {
		for column := range values[0] {
			grid.PaintCell(row+1, column, color.White)
			grid.DrawString(row+1, column, values[row][column], valueFontFace)
		}
	}
	grid.SavePNG()
}
```

![Result](examples/example10/example10.png)


## Example 11

Combining multiple features to draw a Tic Tac Toe game

```go
package main

import (
	"image/color"
	"log"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example11.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 3,
		Columns: 3,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
		LineColor: color.Gray{},
		BorderColor: color.Gray{},
		BackgroundColor: color.NRGBA{R: 220, G: 220, B: 220, A: 255},
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	blue := color.RGBA{B: 128, A: 255}
	green := color.RGBA{G: 128, A: 255}

	grid.DrawCircle(0, 0, gridder.CircleConfig{Radius: 60, Color: blue, StrokeWidth: 4, Stroke: true})
	grid.DrawCircle(1, 1, gridder.CircleConfig{Radius: 60, Color: blue, StrokeWidth: 4, Stroke: true})
	grid.DrawCircle(2, 2, gridder.CircleConfig{Radius: 60, Color: blue, StrokeWidth: 4, Stroke: true})
	grid.DrawLine(2, 0, gridder.LineConfig{Length: 120, Color: green, StrokeWidth: 4, Rotate: 45})
	grid.DrawLine(2, 0, gridder.LineConfig{Length: 120, Color: green, StrokeWidth: 4, Rotate: 135})
	grid.DrawLine(2, 1, gridder.LineConfig{Length: 120, Color: green, StrokeWidth: 4, Rotate: 45})
	grid.DrawLine(2, 1, gridder.LineConfig{Length: 120, Color: green, StrokeWidth: 4, Rotate: 135})
	grid.DrawPath(0, 0, 2, 2, gridder.PathConfig{StrokeWidth: 4, Color: color.RGBA{R: 128, A: 255}})
	grid.SavePNG()
}
```

![Result](examples/example11/example11.png)


## Example 12

Extract image as a byte array. Useful for recording image in a store in text format as example below.

```go
package main

import (
	"bytes"
	"encoding/base64"
	"image/color"
	"log"
	"math/rand"
	"os"
	"time"

	"github.com/shomali11/gridder"
)

func main() {
	imageConfig := gridder.ImageConfig{
		Width: 500,
		Height: 500,
		Name: "example12.png",
	}
	gridConfig := gridder.GridConfig{
		Rows: 20,
		Columns: 20,
		LineStrokeWidth: 2,
		BorderStrokeWidth: 4,
		LineColor: color.Gray{},
		BorderColor: color.Gray{},
		BackgroundColor: color.NRGBA{R: 220, G: 220, B: 220, A: 255},
	}

	grid, err := gridder.New(imageConfig, gridConfig)
	if err != nil {
		log.Fatal(err)
	}

	blue := color.RGBA{B: 128, A: 255}

	// create a random chart
	rand.Seed(time.Now().UnixNano())
	for col := 0; col < gridConfig.Columns; col++ {
		height := rand.Intn(gridConfig.Rows-1)
		for topRow := 0; topRow < height; topRow++ {
			grid.DrawCircle(gridConfig.Rows-topRow, col, gridder.CircleConfig{Radius: 5, Color: blue, StrokeWidth: 4, Stroke: true})
		}
	}

	// encode image as byte string
	bImage := new(bytes.Buffer)
	grid.EncodePNG(bImage)

	// convert to base64 string to support storing into database
	imageString := base64.StdEncoding.EncodeToString(bImage.Bytes())

	// convert back from string and save as binary image
	bDecodedImage, err := base64.StdEncoding.DecodeString(imageString)
	if err != nil {
		log.Fatal(err)
	}

	err = os.WriteFile(imageConfig.Name, bDecodedImage, 0644)
	if err != nil {
		log.Fatal(err)
	}
}
```

![Result](examples/example12/example12.png)

gridder

# :foggy: Image2ascii

[![Build Status](https://travis-ci.org/qeesung/image2ascii.svg?branch=master)](https://travis-ci.org/qeesung/image2ascii)
[![Coverage Status](https://coveralls.io/repos/github/qeesung/image2ascii/badge.svg?branch=master)](https://coveralls.io/github/qeesung/image2ascii?branch=master)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/71a3059b49274dde9d81d58cedd80962)](https://app.codacy.com/app/qeesung/image2ascii?utm_source=github.com&utm_medium=referral&utm_content=qeesung/image2ascii&utm_campaign=Badge_Grade_Dashboard)
[![Go Report Card](https://goreportcard.com/badge/github.com/qeesung/image2ascii)](https://goreportcard.com/report/github.com/qeesung/image2ascii)
[![GoDoc](https://godoc.org/github.com/qeesung/image2ascii?status.svg)](https://godoc.org/github.com/qeesung/image2ascii)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome)

Image2ASCII is a library that converts images into ASCII images and provides command-line tools for easy use.

![demo](https://github.com/qeesung/image2ascii/blob/master/docs/images/lufei.gif?raw=true)

## Installation

```bash
go install github.com/qeesung/image2ascii@latest
```

## CLI usage

```bash
image2ascii version: image2ascii/1.0.0
>> HomePage: https://github.com/qeesung/image2ascii
>> Issue : https://github.com/qeesung/image2ascii/issues
>> Author : qeesung
Usage: image2ascii [-s] -f <filename> -r <ratio> -w <width> -g <height>

Options:
 -c Colored the ascii when output to the terminal (default true)
 -f string
 Image filename to be convert (default "docs/images/lufei.jpg")
 -g int
 Expected image height, -1 for image default height (default -1)
 -i Reversed the ascii when output to the terminal
 -r float
 Ratio to scale the image, ignored when use -w or -g (default 1)
 -s Fit the terminal screen, ignored when use -w, -g, -r (default true)
 -t Stretch the picture to overspread the screen
 -w int
 Expected image width, -1 for image default width (default -1)
```

convert the image fit the screen(default is true)
```bash
image2ascii -f docs/images/pikaqiu2.jpg
```
![demo](https://github.com/qeesung/image2ascii/blob/master/docs/images/pikaqiu_s.gif?raw=true)

convert the image to ascii image with fixed width and height
```bash
# width: 100
# height: 30
image2ascii -f docs/images/baozou.jpg -w 100 -g 30
```
![demo](https://github.com/qeesung/image2ascii/blob/master/docs/images/baozou.gif?raw=true)

convert the image to ascii image by ratio
```bash
# ratio: 0.3
# width: imageWidth * 0.3
# height: imageHeight * 0.3
image2ascii -f docs/images/pikaqiu.jpg -r 0.3
```
![demo](https://github.com/qeesung/image2ascii/blob/master/docs/images/pikaqiu.gif?raw=true)

convert the image to stretch the screen
```bash
image2ascii -f docs/images/long.jpg -t
```
![demo](https://github.com/qeesung/image2ascii/blob/master/docs/images/long.gif?raw=true)

convert the image without the color
```bash
image2ascii -f docs/images/lufei.jpg -s -c=false
```

convert the image disable fit the screen
```bash
image2ascii -f docs/images/lufei.jpg -s=false
```

convert the image reverse the chars
```bash
image2ascii -f docs/images/lufei.jpg -i
```

## Library usage

```golang
package main

import (
	"fmt"
	"github.com/qeesung/image2ascii/convert"
	_ "image/jpeg"
	_ "image/png"
)

func main() {
	// Create convert options
	convertOptions := convert.DefaultOptions
	convertOptions.FixedWidth = 100
	convertOptions.FixedHeight = 40

	// Create the image converter
	converter := convert.NewImageConverter()
	fmt.Print(converter.ImageFile2ASCIIString(imageFilename, &convertOptions))
}
```

convert options

```golang
type Options struct {
	Ratio float64 // convert ratio
	FixedWidth int // convert the image width fixed width
	FixedHeight int // convert the image width fixed height
	FitScreen bool // only work on terminal, fit the terminal height or width
	StretchedScreen bool // only work on terminal, stretch the width and heigh to overspread the terminal screen
	Colored bool // only work on terminal, output ascii with color
	Reversed bool // if reverse the ascii pixels
}
```

supported convert function
```golang
type Converter interface {
	// convert a image object to ascii matrix
	Image2ASCIIMatrix(image image.Image, imageConvertOptions *Options) []string
	// convert a image object to ascii matrix and then join the matrix to a string
	Image2ASCIIString(image image.Image, options *Options) string
	// convert a image object by input a string to ascii matrix
	ImageFile2ASCIIMatrix(imageFilename string, option *Options) []string
	// convert a image object by input a string to ascii matrix then join the matrix to a string
	ImageFile2ASCIIString(imageFilename string, option *Options) string
}
```

## Sample outputs

| Raw Image | ASCII Image |
|:---------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------:|
| ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/lufei.jpg) | ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/lufei_ascii.png) |
| ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/lufei.jpg) | ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/lufei_ascii_colored.png) |
| ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/pikaqiu.jpeg) | ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/pikaqiu_ascii.png) |
| ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/pikaqiu.jpeg) | ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/pikaqiu_ascii_colored.png) |
| ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/baozou.jpg) | ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/baozou_ascii.png) |
| ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/baozou.jpg) | ![](https://raw.githubusercontent.com/qeesung/image2ascii/master/docs/images/baozou_ascii_colored.png) |

## License

This project is under the MIT License. See the [LICENSE](https://github.com/qeesung/image2ascii/blob/master/LICENSE) file for the full license text.

image2ascii

Go binding to ImageMagick's MagickWand C API

# Go Imagick

[![GoDoc](https://godoc.org/gopkg.in/gographics/imagick.v2/imagick?status.svg)](https://gopkg.in/gographics/imagick.v2/imagick)
[![Build](https://github.com/gographics/imagick/workflows/Test/badge.svg)](https://github.com/gographics/imagick/actions?query=workflow%3A%22Test%22)

Go Imagick is a Go bind to ImageMagick's MagickWand C API.

We support two compatibility branches:

```
im-7 (tag v3.x.x): 7.x <= ImageMagick <= 7.x
master (tag v2.x.x): 6.9.1-7 <= ImageMagick <= 6.9.9-35
legacy (tag v1.x.x): 6.7.x <= ImageMagick <= 6.8.9-10
```

They map, respectively, through gopkg.in:

```
gopkg.in/gographics/imagick.v3/imagick
gopkg.in/gographics/imagick.v2/imagick
gopkg.in/gographics/imagick.v1/imagick
```

# Install

## Docker

See [examples/docker](examples/docker)

## Mac OS X

```
brew install imagemagick
```

## Ubuntu / Debian

```
sudo apt-get install libmagickwand-dev
```

## Windows

*Thanks @vprus*

+ Install [msys2-x86_64](http://www.msys2.org/)
+ In msys shell, do:
```
pacman -Syuu
pacman -S mingw-w64-x86_64-gcc
pacman -S mingw-w64-x86_64-pkg-config
pacman -S mingw-w64-x86_64-zlib
pacman -S mingw-w64-x86_64-imagemagick
```

+ Switch to cmd.exe shell, and do:
```
set PATH=<msys64>\mingw64\bin;%PATH%
set PKG_CONFIG_PATH=<msys64>\mingw64\lib\pkgconfig
set MAGICK_CODER_MODULE_PATH=<msys64>\mingw64\lib\ImageMagick-7.0.6\modules-Q16HDRI\coders
go build gopkg.in/gographics/imagick.v3/imagick
```

The default installation path of `msys2` is `C:\msys64` and you must change
`<msys64>` to your installation path of `msys2`.

The `MAGICK_CODER_MODULE_PATH` environment variable tells ImageMagick where to
find the decoders. If you still get the `NoDecodeDelegateForThisImageFormat`
error, then make sure the version number and folders are correct.

## Common

Check if pkg-config is able to find the right ImageMagick include and libs:

```
pkg-config --cflags --libs MagickWand
```

Then go get it:

```
go get gopkg.in/gographics/imagick.v2/imagick
```

Per the security update https://groups.google.com/forum/#!topic/golang-announce/X7N1mvntnoU
you may need whitelist the -Xpreprocessor flag in your environment.

```
export CGO_CFLAGS_ALLOW='-Xpreprocessor'
```

### Build tags

If you want to specify CGO_CFLAGS/CGO_LDFLAGS manually at build time, such as for building statically or without pkg-config, you can use the "no_pkgconfig" build tag:

```
go build -tags no_pkgconfig gopkg.in/gographics/imagick.v2/imagick
```

# Examples

The examples folder is full with usage examples ported from C ones found in here: http://www.imagemagick.org/MagickWand/

# Quick and partial example

```go
package main

import "gopkg.in/gographics/imagick.v2/imagick"

func main() {
 imagick.Initialize()
 defer imagick.Terminate()

 mw := imagick.NewMagickWand()

 ...
}
```
## `Initialize()` and `Terminate`

As per the ImageMagick C API, `Initialize()` should be called only once to set up the resources for using ImageMagick. This is typically done in your `main()` or `init()` for the entire application or library. Applications can defer a call to `Terminate()` to tear down the ImageMagick resources.

It is an error to `Initialize` and `Terminate` multiple times in specific functions and leads to common problems such as crashes or missing delegates. Do not use `Terminate` anywhere other than the absolute end of your need for ImageMagick within the program.

## Managing memory

Since this is a CGO binding, and the Go GC does not manage memory allocated by the C API, it is then necessary to use the Terminate() and Destroy() methods.

Types which are created via `New*` constructors (MagickWand, DrawingWand, PixelIterator, PixelWand,...), or created and returned by methods like `Clone()` are managed by Go GC through the use of finalizers. They are not guaranteed to be cleaned up immediately after the object is not longer in use, but rather at some point later when GC actually executes its finalizers.

If you use struct literals, you should free resources manually:

```go
package main

import "github.com/gographics/imagick/imagick"

func main() {
 imagick.Initialize()
 defer imagick.Terminate()

 mw := imagick.MagickWand{...}
 defer mw.Destroy()

 ...
}
```

Both methods are compatible if constructor methods used:

```go
package main

import "github.com/gographics/imagick/imagick"

func main() {
 imagick.Initialize()
 defer imagick.Terminate()

 mw := imagick.NewMagickWand()
 defer mw.Destroy()

 ...
}
```

But you should NOT mix two ways of object creation:
```go
package main

import "github.com/gographics/imagick/imagick"

func main() {
 imagick.Initialize()
 defer imagick.Terminate()

 mw1 := imagick.MagickWand{...}
 defer mw1.Destroy()

 mw2 := imagick.NewMagickWand()

 ...
}
```

Calling `Destroy()` on types that are either created via `New*` or returned from other functions calls forces the cleanup of the item immediately as opposed to later after garbage collection triggers the finalizer for the object. It would be good practice to explicitly call `Destroy()` to ensure C memory is freed sooner rather than later, depending on how often the GC is triggered.

# License

Copyright (c) 2013-2016, The GoGraphics Team
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright
 notice, this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
 notice, this list of conditions and the following disclaimer in the
 documentation and/or other materials provided with the distribution.
 * Neither the name of the organization nor the
 names of its contributors may be used to endorse or promote products
 derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL HERBERT G. FISCHER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

imagick

Fast and simple HTTP microservice for image resizing

imaginary

# Imaging

[![PkgGoDev](https://pkg.go.dev/badge/github.com/disintegration/imaging)](https://pkg.go.dev/github.com/disintegration/imaging)
[![Build Status](https://travis-ci.org/disintegration/imaging.svg?branch=master)](https://travis-ci.org/disintegration/imaging)
[![Coverage Status](https://coveralls.io/repos/github/disintegration/imaging/badge.svg?branch=master&service=github)](https://coveralls.io/github/disintegration/imaging?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/disintegration/imaging)](https://goreportcard.com/report/github.com/disintegration/imaging)

Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.).

All the image processing functions provided by the package accept any image type that implements `image.Image` interface
as an input, and return a new image of `*image.NRGBA` type (32bit RGBA colors, non-premultiplied alpha).

## Installation

    go get -u github.com/disintegration/imaging

## Documentation

https://pkg.go.dev/github.com/disintegration/imaging

## Usage examples

A few usage examples can be found below. See the documentation for the full list of supported functions.

### Image resizing

```go
// Resize srcImage to size = 128x128px using the Lanczos filter.
dstImage128 := imaging.Resize(srcImage, 128, 128, imaging.Lanczos)

// Resize srcImage to width = 800px preserving the aspect ratio.
dstImage800 := imaging.Resize(srcImage, 800, 0, imaging.Lanczos)

// Scale down srcImage to fit the 800x600px bounding box.
dstImageFit := imaging.Fit(srcImage, 800, 600, imaging.Lanczos)

// Resize and crop the srcImage to fill the 100x100px area.
dstImageFill := imaging.Fill(srcImage, 100, 100, imaging.Center, imaging.Lanczos)
```

Imaging supports image resizing using various resampling filters. The most notable ones:
- `Lanczos` - A high-quality resampling filter for photographic images yielding sharp results.
- `CatmullRom` - A sharp cubic filter that is faster than Lanczos filter while providing similar results.
- `MitchellNetravali` - A cubic filter that produces smoother results with less ringing artifacts than CatmullRom.
- `Linear` - Bilinear resampling filter, produces smooth output. Faster than cubic filters.
- `Box` - Simple and fast averaging filter appropriate for downscaling. When upscaling it's similar to NearestNeighbor.
- `NearestNeighbor` - Fastest resampling filter, no antialiasing.

The full list of supported filters:  NearestNeighbor, Box, Linear, Hermite, MitchellNetravali, CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine. Custom filters can be created using ResampleFilter struct.

**Resampling filters comparison**

Original image:

![srcImage](testdata/branches.png)

The same image resized from 600x400px to 150x100px using different resampling filters.
From faster (lower quality) to slower (higher quality):

Filter                    | Resize result
--------------------------|---------------------------------------------
`imaging.NearestNeighbor` | ![dstImage](testdata/out_resize_nearest.png)
`imaging.Linear`          | ![dstImage](testdata/out_resize_linear.png)
`imaging.CatmullRom`      | ![dstImage](testdata/out_resize_catrom.png)
`imaging.Lanczos`         | ![dstImage](testdata/out_resize_lanczos.png)


### Gaussian Blur

```go
dstImage := imaging.Blur(srcImage, 0.5)
```

Sigma parameter allows to control the strength of the blurring effect.

Original image                     | Sigma = 0.5                            | Sigma = 1.5
-----------------------------------|----------------------------------------|---------------------------------------
![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_blur_0.5.png) | ![dstImage](testdata/out_blur_1.5.png)

### Sharpening

```go
dstImage := imaging.Sharpen(srcImage, 0.5)
```

`Sharpen` uses gaussian function internally. Sigma parameter allows to control the strength of the sharpening effect.

Original image                     | Sigma = 0.5                               | Sigma = 1.5
-----------------------------------|-------------------------------------------|------------------------------------------
![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_sharpen_0.5.png) | ![dstImage](testdata/out_sharpen_1.5.png)

### Gamma correction

```go
dstImage := imaging.AdjustGamma(srcImage, 0.75)
```

Original image                     | Gamma = 0.75                             | Gamma = 1.25
-----------------------------------|------------------------------------------|-----------------------------------------
![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_gamma_0.75.png) | ![dstImage](testdata/out_gamma_1.25.png)

### Contrast adjustment

```go
dstImage := imaging.AdjustContrast(srcImage, 20)
```

Original image                     | Contrast = 15                              | Contrast = -15
-----------------------------------|--------------------------------------------|-------------------------------------------
![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_contrast_p15.png) | ![dstImage](testdata/out_contrast_m15.png)

### Brightness adjustment

```go
dstImage := imaging.AdjustBrightness(srcImage, 20)
```

Original image                     | Brightness = 10                              | Brightness = -10
-----------------------------------|----------------------------------------------|---------------------------------------------
![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_brightness_p10.png) | ![dstImage](testdata/out_brightness_m10.png)

### Saturation adjustment

```go
dstImage := imaging.AdjustSaturation(srcImage, 20)
```

Original image                     | Saturation = 30                              | Saturation = -30
-----------------------------------|----------------------------------------------|---------------------------------------------
![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_saturation_p30.png) | ![dstImage](testdata/out_saturation_m30.png)

### Hue adjustment

```go
dstImage := imaging.AdjustHue(srcImage, 20)
```

Original image                     | Hue = 60                                     | Hue = -60
-----------------------------------|----------------------------------------------|---------------------------------------------
![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_hue_p60.png) | ![dstImage](testdata/out_hue_m60.png)

## FAQ

### Incorrect image orientation after processing (e.g. an image appears rotated after resizing)

Most probably, the given image contains the EXIF orientation tag.
The standard `image/*` packages do not support loading and saving
this kind of information. To fix the issue, try opening images with
the `AutoOrientation` decode option. If this option is set to `true`,
the image orientation is changed after decoding, according to the
orientation tag (if present). Here's the example:

```go
img, err := imaging.Open("test.jpg", imaging.AutoOrientation(true))
```

### What's the difference between `imaging` and `gift` packages?

[imaging](https://github.com/disintegration/imaging)
is designed to be a lightweight and simple image manipulation package.
It provides basic image processing functions and a few helper functions
such as `Open` and `Save`. It consistently returns *image.NRGBA image 
type (8 bits per channel, RGBA).

[gift](https://github.com/disintegration/gift)
supports more advanced image processing, for example, sRGB/Linear color
space conversions. It also supports different output image types
(e.g. 16 bits per channel) and provides easy-to-use API for chaining
multiple processing steps together.

## Example code

```go
package main

import (
	"image"
	"image/color"
	"log"

	"github.com/disintegration/imaging"
)

func main() {
	// Open a test image.
	src, err := imaging.Open("testdata/flowers.png")
	if err != nil {
		log.Fatalf("failed to open image: %v", err)
	}

	// Crop the original image to 300x300px size using the center anchor.
	src = imaging.CropAnchor(src, 300, 300, imaging.Center)

	// Resize the cropped image to width = 200px preserving the aspect ratio.
	src = imaging.Resize(src, 200, 0, imaging.Lanczos)

	// Create a blurred version of the image.
	img1 := imaging.Blur(src, 5)

	// Create a grayscale version of the image with higher contrast and sharpness.
	img2 := imaging.Grayscale(src)
	img2 = imaging.AdjustContrast(img2, 20)
	img2 = imaging.Sharpen(img2, 2)

	// Create an inverted version of the image.
	img3 := imaging.Invert(src)

	// Create an embossed version of the image using a convolution filter.
	img4 := imaging.Convolve3x3(
		src,
		[9]float64{
			-1, -1, 0,
			-1, 1, 1,
			0, 1, 1,
		},
		nil,
	)

	// Create a new image and paste the four produced images into it.
	dst := imaging.New(400, 400, color.NRGBA{0, 0, 0, 0})
	dst = imaging.Paste(dst, img1, image.Pt(0, 0))
	dst = imaging.Paste(dst, img2, image.Pt(0, 200))
	dst = imaging.Paste(dst, img3, image.Pt(200, 0))
	dst = imaging.Paste(dst, img4, image.Pt(200, 200))

	// Save the resulting image as JPEG.
	err = imaging.Save(dst, "testdata/out_example.jpg")
	if err != nil {
		log.Fatalf("failed to save image: %v", err)
	}
}
```

Output:

![dstImage](testdata/out_example.jpg)


imaging

Decoder and conversion tool for MPO 3D Photos

# MPO Encoder/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 and Encoder - Library and CLI Tool

The library and CLI can:

- **Decode** an MPO into individual JPEG frames.
- **Encode** multiple JPEG frames into a Baseline-MP MPO.
- **Convert** an MPO to a stereoscopic (side-by-side) JPEG.
- **Create** anaglyph images (red–cyan, cyan–red, red–green, green–red).

A Web UI for converting MPO to JPEG is available at:

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

## Install CLI Tool

Binaries are available 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
go install github.com/donatj/mpo/cmd/img2mpo@latest
```

## CLI Usage

### mpo2img

Convert an MPO file to a stereoscopic JPEG or anaglyph image.

```
$ mpo2img -help
Usage: mpo2img <mpofile>

Convert a Multi-Picture Object (MPO) file to an image.

 -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")
```

### img2mpo

encode multiple images into an MPO file.

```
$ img2mpo -help
Usage: img2mpo <imagefile> [<imagefile> ...]

Convert one or more images to a Multi-Picture Object (MPO) file.

Supported image formats: JPEG, PNG, GIF, BMP, TIFF, WebP

 -help
 Displays this text
 -outfile string
 Output filename (default "output.mpo")
 -quality int
 JPEG quality [0-100] (default 90)
```

## WIP

Todo:

- Optimization
- Add more control over stereo/anaglyph

picfit

# pt: a golang path tracer

[![Build Status](https://travis-ci.org/fogleman/pt.png?branch=master)](https://travis-ci.org/fogleman/pt) [![GoDoc](https://godoc.org/github.com/fogleman/pt/pt?status.svg)](https://godoc.org/github.com/fogleman/pt/pt)

This is a CPU-only, unidirectional [path tracing](http://en.wikipedia.org/wiki/Path_tracing) engine written in Go. It has lots of features and a simple API.

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

---

### Features

* Supports OBJ and STL
* Supports textures, bump maps and normal maps
* Supports raymarching of signed distance fields
* Supports volume rendering from image slices
* Supports various material properties
* Supports configurable depth of field
* Supports iterative rendering
* Supports adaptive sampling and firefly reduction
* Uses k-d trees to accelerate ray intersection tests
* Uses all CPU cores in parallel
* 100% pure Go with no dependencies besides the standard library

### Installation

    go get -u github.com/fogleman/pt/pt

### Examples

The are [lots of examples](https://github.com/fogleman/pt/tree/master/examples) to learn from! To try them, just run, e.g.

    cd go/src/github.com/fogleman/pt
    go run examples/gopher.go

### Optional Embree Acceleration

You can optionally utilize Intel's Embree ray tracing kernels to accelerate triangle mesh intersections. First, install embree on your system: http://embree.github.io/ Then get the `go-embree` wrapper and checkout the `embree` branch of `pt`.

    git checkout embree
    go get -u github.com/fogleman/go-embree

### Hello World

The following code demonstrates the basics of the API.

```go
package main

import . "github.com/fogleman/pt/pt"

func main() {
	// create a scene
	scene := Scene{}

	// create a material
	material := DiffuseMaterial(White)

	// add the floor (a plane)
	plane := NewPlane(V(0, 0, 0), V(0, 0, 1), material)
	scene.Add(plane)

	// add the ball (a sphere)
	sphere := NewSphere(V(0, 0, 1), 1, material)
	scene.Add(sphere)

	// add a spherical light source
	light := NewSphere(V(0, 0, 5), 1, LightMaterial(White, 8))
	scene.Add(light)

	// position the camera
	camera := LookAt(V(3, 3, 3), V(0, 0, 0.5), V(0, 0, 1), 50)

	// render the scene with progressive refinement
	sampler := NewSampler(4, 4)
	renderer := NewRenderer(&scene, &camera, sampler, 960, 540)
	renderer.AdaptiveSamples = 128
	renderer.IterativeRender("out%03d.png", 1000)
}
```

![Hello World](http://i.imgur.com/FyAmeMx.png)

### Adaptive Sampling

There are several sampling options that can reduce the amount of time needed to converge to an acceptable noise level. Both images below were rendered in 60 seconds. On the left, no advanced features were enabled. On the right, the features listed below were used.

![Gopher](http://i.imgur.com/nidccRU.png)

Here are some of the options that are utilized to achieve this improvement:

- **stratified sampling** - on first intersection, spawn NxN rays in a stratified pattern to ensure well-distributed coverage
- **sample all lights** - at each intersection, sample all lights for direct lighting instead of one random light
- **forced specular reflections** - at each intersection, force both a diffuse and specular bounce and weigh them appropriately
- **adaptive sampling** - spend more time sampling pixels with high variance
- **firefly reduction** - very heavily sample pixels with very high variance

Combining these features results in cleaner, faster renders. The specific parameters that should be used depend greatly on the scene being rendered.

### Links

Here are some resources that I have found useful.

* [WebGL Path Tracing - Evan Wallace](http://madebyevan.com/webgl-path-tracing/)
* [Global Illumination in a Nutshell](http://www.thepolygoners.com/tutorials/GIIntro/GIIntro.htm)
* [Simple Path Tracing - Iñigo Quilez](http://www.iquilezles.org/www/articles/simplepathtracing/simplepathtracing.htm)
* [Realistic Raytracing - Zack Waters](http://web.cs.wpi.edu/~emmanuel/courses/cs563/write_ups/zackw/realistic_raytracing.html)
* [Reflections and Refractions in Ray Tracing - Bram de Greve](http://graphics.stanford.edu/courses/cs148-10-summer/docs/2006--degreve--reflection_refraction.pdf)
* [Better Sampling - Rory Driscoll](http://www.rorydriscoll.com/2009/01/07/better-sampling/)
* [Ray Tracing for Global Illumination - Nelson Max at UC Davis](https://www.youtube.com/playlist?list=PLslgisHe5tBPckSYyKoU3jEA4bqiFmNBJ)
* [Physically Based Rendering - Matt Pharr, Greg Humphreys](http://www.amazon.com/Physically-Based-Rendering-Second-Edition/dp/0123750792)

### Samples

![Go](http://i.imgur.com/LMNUoaM.jpg)

![Dragon](https://www.michaelfogleman.com/static/gallery/out1000c.png)

![Cornell](https://www.michaelfogleman.com/static/gallery/853.png)

![Lucy](https://www.michaelfogleman.com/static/gallery/756b.png)

![SDF](https://www.michaelfogleman.com/static/gallery/470d.png)

![Spheres](https://www.michaelfogleman.com/static/gallery/dof.png)

![Suzanne](http://i.imgur.com/iw32US1.png)

![Molecule](https://www.michaelfogleman.com/static/gallery/600d.png)


Go native WebP encoder with zero external dependencies

[![Codecov Coverage](https://codecov.io/gh/HugoSmits86/nativewebp/branch/main/graph/badge.svg)](https://codecov.io/gh/HugoSmits86/nativewebp)
[![Go Reference](https://pkg.go.dev/badge/github.com/HugoSmits86/nativewebp.svg)](https://pkg.go.dev/github.com/HugoSmits86/nativewebp)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

# Native WebP for Go

This is a native WebP encoder written entirely in Go, with **no dependencies on libwebp** or other external libraries. Designed for performance and efficiency, this encoder generates smaller files than the standard Go PNG encoder and is approximately **50% faster** in execution.

Currently, the encoder supports only WebP lossless images (VP8L).

## Decoding Support

We provide WebP decoding through a wrapper around `golang.org/x/image/webp`, with an additional `DecodeIgnoreAlphaFlag` function to handle VP8X images where the alpha flag causes decoding issues.
## Benchmark

We conducted a quick benchmark to showcase file size reduction and encoding performance. Using an image from Google’s WebP Lossless and Alpha Gallery, we compared the results of our nativewebp encoder with the standard PNG encoder. 
For the PNG encoder, we applied the `png.BestCompression` setting to achieve the most competitive compression outcomes.
 

<table align="center">
 <tr>
 <th></th>
 <th></th>
 <th>PNG encoder</th>
 <th>nativeWebP encoder</th>
 <th>reduction</th>
 </tr>
 <tr>
 <td rowspan="2" height="110px"><img src="https://www.gstatic.com/webp/gallery3/1.png" height="100px"></td>
 <td>file size</td>
 <td>120 kb</td>
 <td>96 kb</td>
 <td>20% smaller</td>
 </tr>
 <tr>
 <td>encoding time</td>
 <td>42945049 ns/op</td>
 <td>27716447 ns/op</td>
 <td>35% faster</td>
 </tr>
 <tr>
 <td rowspan="2" height="110px"><img src="https://www.gstatic.com/webp/gallery3/2.png" height="100px"></td>
 <td>file size</td>
 <td>46 kb</td>
 <td>36 kb</td>
 <td>22% smaller</td>
 </tr>
 <tr>
 <td>encoding time</td>
 <td>98509399 ns/op</td>
 <td>31461759 ns/op</td>
 <td>68% faster</td>
 </tr>
 <tr>
 <td rowspan="2" height="110px"><img src="https://www.gstatic.com/webp/gallery3/3.png" height="100px"></td>
 <td>file size</td>
 <td>236 kb</td>
 <td>194 kb</td>
 <td>18% smaller</td>
 </tr>
 <tr>
 <td>encoding time</td>
 <td>178205535 ns/op</td>
 <td>102454192 ns/op</td>
 <td>43% faster</td>
 </tr>
 <tr>
 <td rowspan="2" height="110px"><img src="https://www.gstatic.com/webp/gallery3/4.png" height="60px"></td>
 <td>file size</td>
 <td>53 kb</td>
 <td>41 kb</td>
 <td>23% smaller</td>
 </tr>
 <tr>
 <td>encoding time</td>
 <td>29088555 ns/op</td>
 <td>14959849 ns/op</td>
 <td>49% faster</td>
 </tr>
 <tr>
 <td rowspan="2" height="110px"><img src="https://www.gstatic.com/webp/gallery3/5.png" height="100px"></td>
 <td>file size</td>
 <td>139 kb</td>
 <td>123 kb</td>
 <td>12% smaller</td>
 </tr>
 <tr>
 <td>encoding time</td>
 <td>63423995 ns/op</td>
 <td>21717392 ns/op</td>
 <td>66% faster</td>
 </tr>
</table>

image source: https://developers.google.com/speed/webp/gallery2



## Installation

To install the nativewebp package, use the following command:
```Bash
go get github.com/HugoSmits86/nativewebp
```
## Usage

Here’s a simple example of how to encode an image:
```Go
file, err := os.Create(name)
if err != nil {
 log.Fatalf("Error creating file %s: %v", name, err)
}
defer file.Close()

err = nativewebp.Encode(file, img, nil)
if err != nil {
 log.Fatalf("Error encoding image to WebP: %v", err)
}
```

Here’s a simple example of how to encode an animation:
```Go
file, err := os.Create(name)
if err != nil {
 log.Fatalf("Error creating file %s: %v", name, err)
}
defer file.Close()

ani := nativewebp.Animation{
 Images: []image.Image{
 frame1,
 frame2,
 },
 Durations: []uint {
 100,
 100,
 },
 Disposals: []uint {
 0,
 0,
 },
 LoopCount: 0,
 BackgroundColor: 0xffffffff,
}

err = nativewebp.EncodeAll(file, &ani, nil)
if err != nil {
 log.Fatalf("Error encoding WebP animation: %v", err)
}
```

nativewebp

Create beautiful generative image patterns from a string

geopattern
===========
> Create beautiful generative image patterns from a string in golang.
> > Go port of [Jason Long](https://github.com/jasonlong)'s awesome [GeoPattern](https://github.com/jasonlong/geo_pattern) library.

[![GoDoc](https://godoc.org/github.com/pravj/geopattern?status.svg)](http://godoc.org/github.com/pravj/geopattern)

> Read geopattern's development story [**geo_pattern: going on the Go path**](http://pravj.github.io/blog/going-on-the-go-path/)

![Nested Squares Pattern](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/pattern.png)

Generate beautiful tiling SVG patterns from a string. The string is converted into a SHA and a color and pattern are determined based on the values in the hash. The color is determined by shifting the hue from a default (or passed in) base color. One of 16 patterns is used (or you can specify one) and the sizing of the pattern elements is also determined by the hash values.

You can use the generated pattern as the background-image for a container. Using the base64 representation of the pattern still results in SVG rendering, so it looks great on retina displays.

See the GitHub Guides [site](https://guides.github.com) as an example of this library in action. GitHub Guides use [Original](https://github.com/jasonlong/geo_pattern) Ruby implementation.

## Installation

`go get github.com/pravj/geopattern`

## Usage

[Example](https://github.com/pravj/geopattern/tree/master/examples) directory contains sample go programs that explains use of `geopattern`

## API

### Arguments for functions returning pattern's string

#### `phrase` : custom pattern phrase

```
args := map[string]string{"phrase": "My Custom Phrase"}
```

#### `generator` : custom pattern type

```
args := map[string]string{"generator": "plaid"}
```

#### `color` : custom background color

```
args := map[string]string{"color": "#3b5998"}
```

#### `baseColor` : custom base color that decides background color

```
args := map[string]string{"baseColor": "#ffcc00"}
```
---

### Functions provided by package for pattern's string representation

#### Get the SVG string :

```
Generate(args)
```

#### Get the Base64 encoded string :

```
Base64String(args)
```

#### Get uri image string :

```
URIimage(args)
```

## Available Pattern

#### chevrons
![Chevrons](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/chevrons.png)

#### concentric-circles
![Concentric-Circles](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/concentric-circles.png)

#### diamonds
![Diamonds](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/diamonds.png)

#### hexagons
![Hexagons](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/hexagons.png)

#### mosaic-squares
![Mosaic-Squares](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/mosaic-squares.png)

#### nested-squares
![Nested-Squares](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/nested-squares.png)

#### octagons
![Octagons](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/octagons.png)

#### overlapping-circles
![Overlapping-Circles](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/overlapping-circles.png)

#### overlapping-rings
![Overlapping-rings](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/overlapping-rings.png)

#### plaid
![Plaid](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/plaid.png)

#### plus-signs
![Plus-Signs](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/plus-signs.png)

#### sine-waves
![Sine-Waves](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/sine-waves.png)

#### squares
![Squares](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/squares.png)

#### tessellation
![Tessellation](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/tessellation.png)

#### triangles
![Triangles](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/triangles.png)

#### xes
![Xes](https://raw.githubusercontent.com/pravj/geopattern/master/examples/patterns/xes.png)

## Dependencies
[go-colorful](https://github.com/lucasb-eyer/go-colorful) : for color space conversion

---

Made with *Muzi* and *Appy* by [Pravendra Singh](https://pravj.github.io)


geopattern

# go-nude

Nudity detection with Go.

(Go porting from https://github.com/pa7/nude.js)

## Example

```go
package main

import (
	"fmt"
	"log"
    "github.com/koyachi/go-nude"
)

func main() {
	imagePath := "images/test2.jpg"

	isNude, err := nude.IsNude(imagePath)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("isNude = %v\n", isNude)
}

```

## Other implementations

- [nude.js](http://www.patrick-wied.at/static/nudejs/)
- [nude.rb](https://github.com/mitukiii/nude.rb)
- [nude.py](https://github.com/hhatto/nude.py)


## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request


go-nude

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

![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

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

# img [![docs](http://godoc.org/hawx.me/code/img?status.svg)](http://godoc.org/hawx.me/code/img)

A collection of image manipulation tools. Each tool takes an input file from
standard input, this needs to be in PNG, JPEG or GIF format. They output the
resulting image (by default in PNG format) to standard output.

To install run,

``` bash
$ go install hawx.me/code/img
```

You can then run `go help` and `go help [command]` for information.

> The aim of _img_ is not to be fast, if you want fast use
> [GraphicsMagick](http://www.graphicsmagick.org/), the aim is to be
> readable. Diving through endless files of C and C++ to find out how a certain
> effect is implemented is no fun, reading a single Go file is hopefully better.


## Example (Command Line)

Here is an example: First we convert the image to greyscale using the values
from the red colour channel, then boost the contrast slightly using a linear
function, and finally tint the image with a dark red.

``` bash
(img greyscale --red | \
 img contrast --linear --ratio 1.5 | \
 img tint --with '#83121344') < input.png > output.png
```

You can see here how easy it is to chain different tools together using pipes.


## Example (Go)

You can also use the _img_ libraries in Go code. We could rewrite the previous
example as,

``` go
// example.go
package main

import (
 "hawx.me/code/img/contrast"
 "hawx.me/code/img/greyscale"
 "hawx.me/code/img/tint"

 "image/png"
 "os"
)

func main() {
 input, _ := os.Open(os.Args[1])
 img, _ := png.Decode(input)

 img = greyscale.Red(img)
 img = contrast.Linear(img, 1.5)
 img = tint.Tint(img, color.NRGBA{131, 18, 19, 255})

 output, _ := os.Create(os.Args[2])
 png.Encode(output, img)
}
```

This can then be compiled and run like `./example input.png output.png`.

The Best Go Libraries For Images (45)