imaging

package
v0.4.0 Latest Latest
Warning

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

 Go to latest Published: Nov 1, 2026 License: MIT Imports: 51 Imported by: 0

Documentation

Overview

Package imaging inspects and transforms bounded, untrusted raster images. Plans are immutable declarations. An Engine owns concurrent processing calls; callers retain ownership of input readers and the engine's lifecycle.

Index

Constants

View Source 
const DefaultAVIFQuality = 60

DefaultAVIFQuality is used unless a plan selects AVIFQuality.

View Source 
const DefaultAVIFSpeed = 10

DefaultAVIFSpeed favors fast encoding. Zero, when explicitly selected with AVIFSpeed, requests the most thorough search; it is not an omitted setting.

View Source 
const DefaultWebPMethod = 4
View Source 
const DefaultWebPQuality = 75
View Source 
const MaxFontBytes = 8 << 20
View Source 
const MaxPathCommands = 1024
View Source 
const (
	MaxTextRunes = 4096
)
View Source 
const MaxTransforms = 32

Variables

View Source 
var ErrNativeUnavailable = safeerror.New("native image capability is unavailable")

ErrNativeUnavailable matches a missing, disabled or incompatible native runtime, or a requested native capability absent from the installed libvips build.

Functions

func Module 

func Module(name foundation.ProviderID, key foundation.Key[*Engine], config Config) foundation.Module

Module constructs the configured engine and drains its actual operations at shutdown. Applications borrow the resolved engine; the module closes it.

Types

type Backend 

type Backend uint8

Backend selects native discovery. AutoBackend is the default: portable codecs always work and an installed libvips runtime adds native capabilities. LibvipsBackend requires discovery to succeed at construction. PortableBackend disables native discovery. No custom build tag or libvips headers are needed. 

const (
	PortableBackend Backend = iota
	LibvipsBackend
	AutoBackend
)

type BlendMode 

type BlendMode uint8

BlendMode combines straight RGB channels before source-over alpha composition. 

const (
	BlendNormal BlendMode = iota
	BlendMultiply
	BlendScreen
	BlendOverlay
	BlendDarken
	BlendLighten
	BlendDifference
	BlendExclusion
)

type Capabilities 

type Capabilities struct {
	Backend              Backend
	Formats              []FormatCapability
	ColorManagement      bool
	MetadataPreservation bool
	SmartCrop            bool
}

Capabilities is an owned snapshot of this engine's available functionality.

func (Capabilities) ForFormat 

func (c Capabilities) ForFormat(format Format) (FormatCapability, bool)

ForFormat returns the capability for format and whether it was found.

type Config 

type Config struct {
	Backend   Backend
	Limits    Limits
	MaxActive int
	Timeout   time.Duration
}

Config sets codec discovery, resource limits, admission capacity and operation timeout.

func DefaultConfig 

func DefaultConfig() Config

DefaultConfig returns automatic codec discovery, default limits, two active calls and a one-minute timeout.

func (Config) Validate 

func (c Config) Validate() error

Validate rejects invalid limits, backend, concurrency or timeout with an invalid fault.

type CropInterest 

type CropInterest uint8

CropInterest selects the libvips heuristic used by SmartFill. 

const (
	CropAttention CropInterest = iota
	CropEntropy
)

type Engine 

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

Engine owns admission and cancellation, not input readers. Close requests cancellation and waits for actual operation exit; Done is never optimistic. Codec/transform calls are synchronous. Cancellation is observed between codec operations and rows; a codec already running retains its capacity until exit.

func New 

func New(config Config) (*Engine, error)

New validates config and creates an engine with bounded admission and codec discovery.

func (*Engine) Capabilities 

func (e *Engine) Capabilities() Capabilities

Capabilities returns an owned snapshot, or an empty snapshot for an invalid engine.

func (*Engine) Close 

func (e *Engine) Close(ctx context.Context) error

Close cancels admitted work and waits for its exit or ctx cancellation.

func (*Engine) Create 

func (e *Engine) Create(ctx context.Context, width, height int, background color.NRGBA, plan Plan) (Result, error)

Create starts from a solid canvas and executes a plan under the same limits and admission ownership as Process. The default output format is PNG.

func (*Engine) Done 

func (e *Engine) Done() <-chan struct{}

Done closes after the engine closes and all admitted work exits.

func (*Engine) Format 

func (*Engine) Format(s fmt.State, _ rune)

Format writes a label without exposing engine internals.

func (*Engine) Inspect 

func (e *Engine) Inspect(ctx context.Context, data []byte) (Info, error)

Inspect examines input with this engine's codecs, limits and admission owner. The package-level Inspect function always uses portable codecs.

func (*Engine) Limits 

func (e *Engine) Limits() Limits

Limits returns the configured limits, or zero limits for a nil engine.

func (*Engine) NativeError 

func (e *Engine) NativeError() error

NativeError reports why this engine cannot use native features. It is nil when libvips is ready. Applications may inspect it during startup; an automatic engine remains usable for portable operations when native discovery fails.

func (*Engine) Process 

func (e *Engine) Process(ctx context.Context, source io.Reader, plan Plan) (Result, error)

Process reads at most the remaining InputBytes+1 after accounting for layers, checks the complete plan before decoding pixels, and publishes no output on failure. It does not close source.

func (*Engine) ProcessBytes 

func (e *Engine) ProcessBytes(ctx context.Context, data []byte, plan Plan) (Result, error)

ProcessBytes runs the same bounded pipeline directly on data without copying it. data must not change during the call.

func (*Engine) Validate 

func (e *Engine) Validate() error

Validate rejects a nil or uninitialized engine and invalid configuration.

func (*Engine) ValidatePlan 

func (e *Engine) ValidatePlan(p Plan) error

ValidatePlan checks the plan and rejects features unavailable in this engine.

type Font 

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

Font owns an immutable TrueType/OpenType font. Load application font assets once and reuse them across plans; mutable font faces never escape the engine. Font loading is for application assets, not arbitrary uploaded fonts.

func BuiltinFont 

func BuiltinFont(style FontStyle) (Font, error)

BuiltinFont loads one of the Go fonts already included with Foundry. Apps need no font download, filesystem path or additional Go dependency.

func ParseFont 

func ParseFont(data []byte) (Font, error)

ParseFont copies data before parsing. Collections, WOFF and bitmap/color fonts are not supported by this portable outline renderer.

func (Font) Format 

func (Font) Format(s fmt.State, _ rune)

Format writes a label without exposing font data.

func (Font) GoString 

func (Font) GoString() string

GoString returns a label without exposing font data.

func (Font) String 

func (Font) String() string

String returns a label without exposing font data.

type FontStyle 

type FontStyle uint8

FontStyle selects a bundled Go font. 

const (
	FontRegular FontStyle = iota
	FontBold
	FontItalic
	FontBoldItalic
	FontMono
)

type Format 

type Format string

Format identifies an image encoding or container. 

const (
	JPEG Format = "jpeg"
	PNG  Format = "png"
	WebP Format = "webp"
	GIF  Format = "gif"
	BMP  Format = "bmp"
	TIFF Format = "tiff"
	AVIF Format = "avif"
	ICO  Format = "ico"
	HEIF Format = "heif"
	// HEIC is HEIF encoded with HEVC; both names use the canonical HEIF format.
	HEIC     Format = HEIF
	JPEG2000 Format = "jp2"
	JPEGXL   Format = "jxl"
	SVG      Format = "svg"
)

func ParseExtension 

func ParseExtension(extension string) (Format, error)

ParseExtension is a filename convenience, never media validation.

func ParseMediaType 

func ParseMediaType(media string) (Format, error)

ParseMediaType recognizes image media types. Recognition does not imply that a particular engine can read or write the format; consult its Capabilities.

func (Format) CanDecode 

func (f Format) CanDecode() bool

CanDecode reports whether the portable engine can read this format.

func (Format) Extension 

func (f Format) Extension() string

Extension returns the filename extension without a dot; JPEG uses jpg.

func (Format) MediaType 

func (f Format) MediaType() string

MediaType returns the image media type, or an empty string for an unknown format.

func (Format) Validate 

func (f Format) Validate() error

Validate rejects unrecognized formats with an invalid fault; it does not check engine availability.

type FormatCapability 

type FormatCapability struct {
	Format                        Format
	Read, Write                   bool
	ReadAnimation, WriteAnimation bool
	// WriteMetadata reports a native writer with verified ICC round-trip support.
	// Other metadata families are retained where that format supports them.
	WriteMetadata bool
}

FormatCapability distinguishes reading, writing and animation support. A recognized format need not support every operation.

type Frames 

type Frames uint8

Frames selects whether animation is rejected, reduced to its first frame or preserved. 

const (
	RejectAnimation Frames = iota
	FirstFrame
	PreserveAnimation
)

type Info 

type Info struct {
	Format                Format
	Width, Height, Images int
	Animated              bool
	Orientation           uint8
}

Info is inspected container information, not proof that compressed pixels are valid. Process performs full decoding of the selected image. Images counts frames, TIFF pages or ICO representations; only animation sets Animated.

func Inspect 

func Inspect(data []byte, limits Limits) (Info, error)

Inspect does no pixel decode and never consults filename or supplied MIME. Input must remain unchanged for the duration of this synchronous call.

type Limits 

type Limits struct {
	InputBytes, OutputBytes int64
	Width, Height           int
	Pixels                  int64
	Frames                  int
	WorkingBytes            int64
}

Limits apply before pixel decoding, before each transform, and to output. WorkingBytes bounds the admitted workspace of each pipeline phase: the retained encoded input plus the pixel buffers live in that phase (decoder buffers, each transform's input, output and scratch, and the encoder's working copies with the owned output allowance). Per-pixel costs come from measurements of the engine's codecs (see the imaging guide). It is not a process heap or OS memory quota; codec/runtime bookkeeping and garbage collection are separate. There is deliberately no unbounded input option.

func DefaultLimits 

func DefaultLimits() Limits

DefaultLimits returns the default input, output, dimension, frame and workspace bounds.

func (Limits) Validate 

func (l Limits) Validate() error

Validate rejects nonpositive or excessive resource bounds with an invalid fault.

type MaskMode 

type MaskMode uint8

MaskMode selects alpha-only or luminance-weighted mask coverage. 

const (
	AlphaMask MaskMode = iota
	LuminanceMask
)

type Metadata 

type Metadata uint8

Metadata selects retention after transformation. The default strips metadata. Preservation requires an available libvips runtime and an output with WriteMetadata support. PreserveMetadata includes EXIF (including GPS), XMP, IPTC and ICC where supported; obsolete EXIF orientation, dimensions and thumbnails are normalized on output. 

const (
	StripMetadata Metadata = iota
	PreserveMetadata
	PreserveColorProfile
)

type MissingGlyph 

type MissingGlyph uint8

MissingGlyph selects whether unavailable glyphs fail or use the font missing-glyph outline. 

const (
	RejectMissingGlyph MissingGlyph = iota
	ReplaceMissingGlyph
)

type Orientation 

type Orientation uint8

Orientation selects whether input orientation metadata is applied or ignored. 

const (
	ApplyOrientation Orientation = iota
	IgnoreOrientation
)

type PNGCompression 

type PNGCompression uint8

PNGCompression selects a lossless PNG/APNG compression effort. Compression changes encoding time and file size, never the represented pixel values. 

const (
	PNGDefaultCompression PNGCompression = iota
	PNGNoCompression
	PNGBestSpeed
	PNGBestCompression
)

type Path 

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

Path is immutable. Each builder returns an independent path. Closed contours use nonzero winding; reverse an inner contour's direction to make a hole.

func NewPath 

func NewPath() Path

NewPath returns an empty path; add drawing commands before validating or rendering it.

func (Path) Close 

func (p Path) Close() Path

Close returns a path with the current contour closed.

func (Path) CubicTo 

func (p Path) CubicTo(cx1, cy1, cx2, cy2, x, y float64) Path

CubicTo returns a path with a cubic curve using two control points and an endpoint.

func (Path) LineTo 

func (p Path) LineTo(x, y float64) Path

LineTo returns a path with a line to the supplied endpoint.

func (Path) MoveTo 

func (p Path) MoveTo(x, y float64) Path

MoveTo returns a path with a new contour starting at the supplied coordinates.

func (Path) QuadraticTo 

func (p Path) QuadraticTo(cx, cy, x, y float64) Path

QuadraticTo returns a path with a quadratic curve using a control point and an endpoint.

func (Path) Validate 

func (p Path) Validate() error

Validate rejects empty, excessive or malformed commands and invalid coordinates with an invalid fault.

type Placement 

type Placement struct {
	Position Position
	X, Y     int
	Opacity  value.Optional[float64]
	Blend    BlendMode
}

Placement positions a layer relative to the canvas. Positive offsets move right/down, including at right/bottom anchors; use negative offsets for inset. Omitted opacity is 1; an explicitly supplied zero is fully transparent.

func (Placement) Validate 

func (p Placement) Validate() error

Validate rejects invalid anchors, blend modes, offsets and opacity with an invalid fault.

type Plan 

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

Plan holds copied values and immutable image results, never callbacks or caller-owned mutable image buffers. Methods return independent plans; a zero plan has no transforms and keeps the detected format. Quality applies only to JPEG, including a detected JPEG.

func NewPlan 

func NewPlan() Plan

NewPlan returns a zero plan with no transforms and the detected input format.

func (Plan) AVIFAlphaQuality 

func (p Plan) AVIFAlphaQuality(quality int) Plan

AVIFAlphaQuality sets alpha quality independently to 1..100; by default it follows AVIFQuality. Requires an explicit AVIF output.

func (Plan) AVIFQuality 

func (p Plan) AVIFQuality(q int) Plan

AVIFQuality selects AVIF quality 1..100 (100 uses the lowest quantizer). RGB conversion and chroma subsampling still apply; it requires an explicit AVIF output. The default is DefaultAVIFQuality.

func (Plan) AVIFSpeed 

func (p Plan) AVIFSpeed(speed int) Plan

AVIFSpeed selects encoding speed 0..10, from most thorough to fastest search. The default is DefaultAVIFSpeed. Requires an explicit AVIF output. A slow synchronous encode retains engine capacity until it actually exits.

func (Plan) Background 

func (p Plan) Background(c color.NRGBA) Plan

Background flattens the result over an opaque color before encoding, so a format without alpha (JPEG) does not render transparent pixels as black. It applies to every output format when set.

func (Plan) Blur 

func (p Plan) Blur(sigma float64) Plan

Blur returns a plan with a Gaussian blur using sigma.

func (Plan) Brightness 

func (p Plan) Brightness(offset int) Plan

Brightness adds an 8-bit channel offset, preserving alpha.

func (Plan) Canvas 

func (p Plan) Canvas(width, height int, background color.NRGBA, position Position) Plan

Canvas changes the canvas without resampling, clipping or extending around the anchor. background fills new pixels and may be transparent.

func (Plan) CanvasRelative 

func (p Plan) CanvasRelative(width, height int, background color.NRGBA, position Position) Plan

CanvasRelative adds signed deltas to the current canvas size.

func (Plan) Circle 

func (p Plan) Circle(x, y, radius float64, style ShapeStyle) Plan

Circle returns a plan drawing a circle with the supplied center, positive radius and style.

func (Plan) Contain 

func (p Plan) Contain(width, height int, background color.NRGBA, position Position) Plan

Contain is Pad with enlargement enabled.

func (Plan) Contrast 

func (p Plan) Contrast(value float64) Plan

Contrast applies the reference framework's squared (100+value)/100 factor around the channel midpoint. Values outside [-100,100] are rejected.

func (Plan) Crop 

func (p Plan) Crop(x, y, width, height int) Plan

Crop returns a plan cropping the specified rectangle in pixel coordinates.

func (Plan) CropAt 

func (p Plan) CropAt(width, height int, position Position) Plan

CropAt takes a positioned rectangle without resampling. It must fit inside the input; use Canvas to extend the image instead.

func (Plan) Draw 

func (p Plan) Draw(path Path, style ShapeStyle) Plan

Draw adds an antialiased vector path. Open contours are closed for filling; strokes close only contours with an explicit Close command.

func (Plan) Ellipse 

func (p Plan) Ellipse(x, y, radiusX, radiusY float64, style ShapeStyle) Plan

Ellipse uses a center and positive horizontal/vertical radii.

func (Plan) Fill 

func (p Plan) Fill(width, height int, upscale bool) Plan

Fill returns a plan resizing to cover the dimensions and cropping at the center; insufficient source size fails when upscale is false.

func (Plan) FillAt 

func (p Plan) FillAt(width, height int, upscale bool, position Position) Plan

FillAt resizes to cover the target and crops at position. A target requiring enlargement fails when upscale is false, just as with Fill.

func (Plan) Fit 

func (p Plan) Fit(width, height int, upscale bool) Plan

Fit returns a plan resizing proportionally within the dimensions, allowing enlargement only when upscale is true.

func (Plan) FitHeight 

func (p Plan) FitHeight(height int, upscale bool) Plan

FitHeight preserves the aspect ratio while targeting one height.

func (Plan) FitWidth 

func (p Plan) FitWidth(width int, upscale bool) Plan

FitWidth preserves the aspect ratio while targeting one width.

func (Plan) FlipHorizontal 

func (p Plan) FlipHorizontal() Plan

FlipHorizontal returns a plan mirroring pixels horizontally.

func (Plan) FlipVertical 

func (p Plan) FlipVertical() Plan

FlipVertical returns a plan mirroring pixels vertically.

func (Plan) Format 

func (p Plan) Format(f Format) Plan

Format returns a plan with the selected output format.

func (Plan) Frames 

func (p Plan) Frames(f Frames) Plan

Frames returns a plan with the selected animation handling policy.

func (Plan) Gamma 

func (p Plan) Gamma(value float64) Plan

Gamma applies gamma correction. Values above one lighten; below one darken.

func (Plan) GoString 

func (Plan) GoString() string

GoString returns a label without exposing prepared layer bytes.

func (Plan) Grayscale 

func (p Plan) Grayscale() Plan

Grayscale returns a plan converting pixels to grayscale.

func (Plan) HEIFQuality 

func (p Plan) HEIFQuality(quality int) Plan

HEIFQuality selects HEVC quality 1..100, default 85. Requires explicit HEIF output and an available libvips runtime. A quality of 100 is not a lossless guarantee.

func (Plan) Hue 

func (p Plan) Hue(degrees float64) Plan

Hue shifts hue by degrees in [-360,360].

func (Plan) Insert 

func (p Plan) Insert(layer Result, placement Placement) Plan

Insert composites an immutable processed Result onto this image. Prepare the layer once with Engine.Process, then reuse it in concurrent plans. Pixels outside the canvas are clipped; layer bytes and decoding count toward limits.

func (Plan) Invert 

func (p Plan) Invert() Plan

Invert reverses RGB channels, preserving alpha.

func (Plan) JPEG2000Quality 

func (p Plan) JPEG2000Quality(quality int) Plan

JPEG2000Quality selects lossy quality 1..100 for explicit JPEG2000 output. Omitting it keeps the default lossless encoding. Requires an available libvips runtime.

func (Plan) JPEGQuality 

func (p Plan) JPEGQuality(q int) Plan

JPEGQuality returns a plan with JPEG quality; zero selects the default quality.

func (Plan) JPEGXLQuality 

func (p Plan) JPEGXLQuality(quality int) Plan

JPEGXLQuality selects lossy quality 1..100 for explicit JPEGXL output. Omitting it keeps the default lossless encoding. Requires an available libvips runtime.

func (Plan) Line 

func (p Plan) Line(x1, y1, x2, y2, width float64, c color.NRGBA) Plan

Line returns a plan drawing a stroke between the supplied endpoints.

func (Plan) Mask 

func (p Plan) Mask(layer Result, placement Placement, mode MaskMode) Plan

Mask multiplies existing alpha by mask alpha, and for LuminanceMask also by weighted RGB luminance. Pixels outside the positioned mask become transparent. Placement opacity is supported; blend modes other than BlendNormal reject.

func (Plan) Metadata 

func (p Plan) Metadata(m Metadata) Plan

Metadata returns a plan with the selected metadata retention policy.

func (Plan) Orientation 

func (p Plan) Orientation(o Orientation) Plan

Orientation returns a plan with the selected input orientation policy.

func (Plan) PNGCompression 

func (p Plan) PNGCompression(compression PNGCompression) Plan

PNGCompression selects compression for every encoded PNG/APNG frame. It requires an explicit PNG output, including PNGDefaultCompression.

func (Plan) Pad 

func (p Plan) Pad(width, height int, background color.NRGBA, position Position) Plan

Pad fits without enlargement into an exact canvas and fills unused pixels. background may be transparent.

func (Plan) Pixelate 

func (p Plan) Pixelate(size int) Plan

Pixelate replaces square blocks with their average color.

func (Plan) Polygon 

func (p Plan) Polygon(points []Point, style ShapeStyle) Plan

Polygon snapshots points. At least three points are required.

func (Plan) Rectangle 

func (p Plan) Rectangle(x, y, width, height float64, style ShapeStyle) Plan

Rectangle returns a plan drawing a rectangle from its top-left corner with positive dimensions.

func (Plan) Resampling 

func (p Plan) Resampling(r Resampling) Plan

Resampling returns a plan using the selected filter for resize operations.

func (Plan) Resize 

func (p Plan) Resize(width, height int) Plan

Resize returns a plan resizing exactly to the dimensions, allowing enlargement.

func (Plan) ResizeDown 

func (p Plan) ResizeDown(width, height int) Plan

ResizeDown resizes each axis independently, without enlarging either axis.

func (Plan) Rotate 

func (p Plan) Rotate(r Rotation) Plan

Rotate returns a plan rotating by the selected quarter-turn angle.

func (Plan) RotateDegrees 

func (p Plan) RotateDegrees(degrees float64, background color.NRGBA) Plan

RotateDegrees rotates clockwise, expanding the canvas to contain the image. Angles are finite in [-360,360]. Cubic interpolation is used, except exact quarter-turns, which retain pixels without interpolation.

func (Plan) Saturation 

func (p Plan) Saturation(percentage float64) Plan

Saturation changes saturation by a percentage in [-100,100].

func (Plan) Sepia 

func (p Plan) Sepia(percentage float64) Plan

Sepia applies a sepia effect with strength in [0,100].

func (Plan) Sharpen 

func (p Plan) Sharpen(sigma, amount, threshold float64) Plan

Sharpen applies an unsharp mask. Sigma is in (0,100], amount in [0,10], threshold in [0,1]. Typical values are (1, 1, 0.02).

func (Plan) SmartFill 

func (p Plan) SmartFill(width, height int, upscale bool, interest CropInterest) Plan

SmartFill resizes to cover the requested canvas and selects a crop using visual attention or entropy. Requires an available libvips runtime. Like Fill, it rejects an insufficient source size when upscale is false.

func (Plan) String 

func (Plan) String() string

String and GoString redact prepared layer bytes from routine/debug formatting. Format is already the fluent output-format method, so Plan is not a Formatter.

func (Plan) Text 

func (p Plan) Text(text string, options TextOptions) Plan

Text draws antialiased outline glyphs with kerning. Font assets and the text are owned by the immutable plan. This renderer lays out left-to-right glyphs; it does not perform bidirectional layout, script shaping or color emoji.

func (Plan) Threshold 

func (p Plan) Threshold(percentage float64) Plan

Threshold makes RGB black or white using a luminance percentage in [0,100].

func (Plan) ToSRGB 

func (p Plan) ToSRGB() Plan

ToSRGB converts an embedded ICC profile to 8-bit sRGB before applying the plan. Images without a profile use their declared color interpretation. Requires an available libvips runtime; malformed profiles fail instead of being ignored.

func (Plan) Validate 

func (p Plan) Validate() error

Validate rejects invalid settings and transforms with an invalid fault; it does not inspect input pixels.

func (Plan) WebPMethod 

func (p Plan) WebPMethod(method int) Plan

WebPMethod selects search effort 0..6 (fastest to most thorough), default DefaultWebPMethod. Explicit zero is preserved. Applies to either WebP mode.

func (Plan) WebPMode 

func (p Plan) WebPMode(mode WebPMode) Plan

WebPMode selects WebPLossless (the default) or WebPLossy. Requires explicit WebP output. Lossless preserves the RGB of fully transparent pixels too.

func (Plan) WebPQuality 

func (p Plan) WebPQuality(quality int) Plan

WebPQuality selects lossy color quality 1..100, default DefaultWebPQuality. Requires explicit WebP output and WebPLossy mode; 100 is still lossy.

type Point 

type Point struct{ X, Y float64 }

Drawing coordinates are measured in pixels from the top-left canvas corner. Finite coordinates in [-65535,65535] are accepted and clipped to the canvas.

type Position 

type Position uint8

Position anchors an image or crop rectangle. The zero value is Center. 

const (
	Center Position = iota
	TopLeft
	Top
	TopRight
	Left
	Right
	BottomLeft
	Bottom
	BottomRight
)

type Resampling 

type Resampling uint8

Resampling selects the reconstruction filter used by every resize in a plan. Lanczos is the default. NearestNeighbor is useful for pixel art. 

const (
	Lanczos Resampling = iota
	Cubic
	Linear
	Box
	NearestNeighbor
)

type Result 

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

Result owns encoded output. Reader exposes read-only access; Bytes returns an independent copy. Routine formatting never exports image bytes.

func (Result) Bytes 

func (r Result) Bytes() []byte

Bytes returns an independent copy of the encoded output.

func (Result) Format 

func (Result) Format(s fmt.State, _ rune)

Format writes a label without exposing encoded image bytes.

func (Result) Info 

func (r Result) Info() Info

Info returns metadata describing the encoded output.

func (Result) MarshalJSON 

func (Result) MarshalJSON() ([]byte, error)

MarshalJSON rejects implicit byte export with an invalid fault.

func (Result) Reader 

func (r Result) Reader() io.Reader

Reader returns a new reader over the immutable encoded output.

func (Result) Size 

func (r Result) Size() int64

Size returns the encoded output length in bytes.

type Rotation 

type Rotation uint16

Rotation specifies a supported rotation angle in degrees. 

const (
	Rotate90  Rotation = 90
	Rotate180 Rotation = 180
	Rotate270 Rotation = 270
)

type ShapeStyle 

type ShapeStyle struct {
	Fill        color.NRGBA
	Stroke      color.NRGBA
	StrokeWidth float64
}

ShapeStyle draws the fill first, then a centered stroke with round joins and round caps. Transparent colors and a zero stroke width disable that paint.

func (ShapeStyle) Validate 

func (s ShapeStyle) Validate() error

Validate rejects nonfinite, negative or excessive stroke widths with an invalid fault.

type TextAlignment 

type TextAlignment uint8

TextAlignment selects horizontal alignment within the text block. 

const (
	AlignLeft TextAlignment = iota
	AlignCenter
	AlignRight
)

type TextOptions 

type TextOptions struct {
	Font         Font
	Size         float64
	Color        color.NRGBA
	Position     Position
	X, Y         int
	MaxWidth     int
	Align        TextAlignment
	LineHeight   float64
	MissingGlyph MissingGlyph
}

TextOptions positions a block of line boxes, with the first baseline one font ascent below its top. Size is pixels per em (1..512). MaxWidth wraps at spaces, splitting long words when necessary; zero disables wrapping. Explicit newlines are preserved, CRLF is normalized, and tabs become four spaces. LineHeight is a size multiplier (0.5..4); zero selects 1.2. Align applies within MaxWidth, or within the longest line when MaxWidth is zero.

func (TextOptions) Validate 

func (o TextOptions) Validate() error

Validate rejects an unloaded font or invalid text layout settings with an invalid fault.

type WebPMode 

type WebPMode uint8

WebPMode selects exact lossless pixels or lossy 4:2:0 color compression. Alpha remains lossless in both modes. 

const (
	WebPLossless WebPMode = iota
	WebPLossy
)

Source Files

View all Source files

Jump to

Keyboard shortcuts

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