// Save returns an Image compressed using the given SaveOptions as a byte slice.
func Save(image *vips.Image, options SaveOptions) ([]byte, error) {
if options.Quality < 1 || options.Quality > 100 {
options.Quality = DefaultQuality
}
if options.Compression < 1 || options.Compression > 9 {
options.Compression = DefaultCompression
}
// Make a decision on image format and whether we're using lossless.
if options.Format == Unknown {
if options.AllowWebp {
options.Format = Webp
} else if image.HasAlpha() || useLossless(image, options) {
options.Format = Png
} else {
options.Format = Jpeg
}
} else if options.Format == Webp && !useLossless(image, options) {
options.Lossless = false
}
switch options.Format {
case Jpeg:
return jpegSave(image, options)
case Png:
return pngSave(image, options)
case Webp:
return webpSave(image, options)
default:
return nil, ErrInvalidSaveFormat
}
}
// MetadataImage returns Metadata from an Image. Format is always unset.
func MetadataImage(image *vips.Image) Metadata {
o := DetectOrientation(image)
w, h := o.Dimensions(image.Xsize(), image.Ysize())
if w <= 0 || h <= 0 {
panic("Invalid image dimensions.")
}
return Metadata{Width: w, Height: h, Orientation: o, HasAlpha: image.HasAlpha()}
}
func resize(image *vips.Image, iw, ih int, fastResize bool, blurSigma float64, sharpen bool) error {
m := format.MetadataImage(image)
// Interpolation of RGB values with an alpha channel isn't safe
// unless the values are pre-multiplied. Undo this later.
// This also flattens fully transparent pixels to black.
premultiply := image.HasAlpha()
if premultiply {
if err := image.Premultiply(); err != nil {
return err
}
}
// A box filter will quickly get us within 2x of the final size, at some quality cost.
if fastResize {
// Shrink factors can be passed independently here, which
// may not be sane since Resize()'s blur and sharpening
// steps expect a normal aspect ratio.
wshrink := math.Floor(float64(m.Width) / float64(iw))
hshrink := math.Floor(float64(m.Height) / float64(ih))
if wshrink >= 2 || hshrink >= 2 {
// Shrink rounds down the number of pixels.
if err := image.Shrink(wshrink, hshrink); err != nil {
return err
}
m = format.MetadataImage(image)
}
}
// If necessary, do a high-quality resize to scale to final size.
if iw < m.Width || ih < m.Height {
// Vips 8.3 sometimes produces 1px smaller images than desired without the rounding help here.
if err := image.Resize((float64(iw)+vips.ResizeOffset)/float64(m.Width), (float64(ih)+vips.ResizeOffset)/float64(m.Height)); err != nil {
return err
}
}
if blurSigma > 0.0 {
if err := image.Gaussblur(blurSigma); err != nil {
return err
}
}
if sharpen {
if err := image.MildSharpen(); err != nil {
return err
}
}
// Unpremultiply after all operations that touch adjacent pixels.
if premultiply {
if err := image.Unpremultiply(); err != nil {
return err
}
}
return nil
}
func minTransparency(image *vips.Image) (float64, error) {
if !image.HasAlpha() {
return 1.0, nil
}
band, err := image.Copy()
if err != nil {
return 0, err
}
defer band.Close()
if err := band.ExtractBand(band.ImageGetBands()-1, 1); err != nil {
return 0, err
}
// If all pixels are at least 90% opaque, we can flatten.
min, err := band.Min()
if err != nil {
return 0, err
}
return min / band.MaxAlpha(), nil
}