imgconv

The imgconv CLI tool allows for batch or single image conversion, resizing, watermarking, and format changes. It supports various formats including jpg, jpeg, png, gif, tif, tiff, bmp, pdf, and webp.

Common Tasks

Convert a directory of images to a specific format:

imgconv --src ./input_folder --dst ./output_folder --format png

Resize images by width and height (preserving aspect ratio if one is 0):

imgconv --src photo.jpg --dst output.png --width 800

Resize images by percentage:

imgconv --src photo.jpg --dst output.png --percent 50

Add a watermark with custom opacity and offset:

imgconv --src photo.jpg --dst output.png --watermark ./logo.png --opacity 150 -x 10 -y 10

Convert to grayscale and use a white background for transparency:

imgconv --src photo.png --dst output.jpg --gray --white-background

# Example: Convert all images in 'photos' to webp with 80% quality
imgconv --src photos --dst converted_photos --format webp --quality 80

This example demonstrates a full workflow: opening an image, resizing it, adding a random watermark, writing it as a TIFF, writing it as a WEBP with compression, and splitting it horizontally.

package main

import (
	"io"
	"log"

	"github.com/HugoSmits86/nativewebp"
	"github.com/sunshineplan/imgconv"
)

func main() {
	// Open a test image.
	src, err := imgconv.Open("testdata/video-001.png")
	if err != nil {
		log.Fatalf("failed to open image: %v", err)
	}

	// Resize the image to width = 200px preserving the aspect ratio.
	mark := imgconv.Resize(src, &imgconv.ResizeOption{Width: 200})

	// Add random watermark set opacity = 128.
	dst := imgconv.Watermark(src, &imgconv.WatermarkOption{Mark: mark, Opacity: 128, Random: true})

	// Write the resulting image as TIFF.
	if err := imgconv.Write(io.Discard, dst, &imgconv.FormatOption{Format: imgconv.TIFF}); err != nil {
		log.Fatalf("failed to write image: %v", err)
	}

	// Write the resulting image as WEBP with an explicit compression level.
	if err := imgconv.Write(io.Discard, dst, &imgconv.FormatOption{
		Format: imgconv.WEBP,
		EncodeOption: []imgconv.EncodeOption{
			imgconv.WEBPCompressionLevel(nativewebp.DefaultCompression),
		},
	}); err != nil {
		log.Fatalf("failed to write webp image: %v", err)
	}

	// Split the image into 3 parts horizontally.
	imgs, err := imgconv.Split(src, 3, imgconv.SplitHorizontalMode)
	if err != nil {
		log.Fatalf("failed to split image: %v", err)
	}
}

The EncodeOption pattern allows fine-grained control over the encoding process for different formats. Use these functions to build your EncodeOption slice:

The Options struct is the primary way to configure image processing tasks such as watermarking, resizing, grayscale conversion, and format encoding. You can initialize a default configuration using NewOptions() and then use a fluent API to chain settings.

Available configuration methods:

• SetWatermark(mark image.Image, opacity uint): Adds a watermark image. If opacity is 0, it defaults to 128.
• SetResize(width, height int, percent float64): Configures image resizing dimensions and percentage.
• SetFormat(f Format, options ...EncodeOption): Sets the output image format and any format-specific encoding options.
• SetGray(gray bool): Enables or disables grayscale conversion.

import (
	"image"
	"os"
	"imgconv"
)

// Example: Create options for a resized, grayscale JPEG with a watermark
func main() {
	watermark, _ := loadWatermarkImage()
	file, _ := os.Create("output.jpg")
	defer file.Close()

	baseImage, _ := loadBaseImage()

	err := imgconv.NewOptions().
		SetGray(true).
		SetResize(800, 600, 1.0).
		SetWatermark(watermark, 200).
		SetFormat(imgconv.JPEG).
		Convert(file, baseImage)

	if err != nil {
		panic(err)
	}
}