README

Imaging

GoDoc Build Status Coverage Status Go Report Card

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

http://godoc.org/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
// 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

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
imaging.Linear dstImage
imaging.CatmullRom dstImage
imaging.Lanczos dstImage
Gaussian Blur
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 dstImage dstImage
Sharpening
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 dstImage dstImage
Gamma correction
dstImage := imaging.AdjustGamma(srcImage, 0.75)
Original image Gamma = 0.75 Gamma = 1.25
srcImage dstImage dstImage
Contrast adjustment
dstImage := imaging.AdjustContrast(srcImage, 20)
Original image Contrast = 15 Contrast = -15
srcImage dstImage dstImage
Brightness adjustment
dstImage := imaging.AdjustBrightness(srcImage, 20)
Original image Brightness = 10 Brightness = -10
srcImage dstImage dstImage
Saturation adjustment
dstImage := imaging.AdjustSaturation(srcImage, 20)
Original image Saturation = 30 Saturation = -30
srcImage dstImage dstImage

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 stadard 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:

img, err := imaging.Open("test.jpg", imaging.AutoOrientation(true))
What's the difference between imaging and gift packages?

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

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

Expand ▾ Collapse ▴

Documentation

Overview

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

    Example
    Output:
    
    

    Index

    Examples

    Constants

    This section is empty.

    Variables

    View Source
    var ErrUnsupportedFormat = errors.New("imaging: unsupported image format")

      ErrUnsupportedFormat means the given image format is not supported.

      Functions

      func AdjustBrightness

      func AdjustBrightness(img image.Image, percentage float64) *image.NRGBA

        AdjustBrightness changes the brightness of the image using the percentage parameter and returns the adjusted image. The percentage must be in range (-100, 100). The percentage = 0 gives the original image. The percentage = -100 gives solid black image. The percentage = 100 gives solid white image.

        Examples:

        dstImage = imaging.AdjustBrightness(srcImage, -15) // Decrease image brightness by 15%.
        dstImage = imaging.AdjustBrightness(srcImage, 10) // Increase image brightness by 10%.
        

        func AdjustContrast

        func AdjustContrast(img image.Image, percentage float64) *image.NRGBA

          AdjustContrast changes the contrast of the image using the percentage parameter and returns the adjusted image. The percentage must be in range (-100, 100). The percentage = 0 gives the original image. The percentage = -100 gives solid gray image.

          Examples:

          dstImage = imaging.AdjustContrast(srcImage, -10) // Decrease image contrast by 10%.
          dstImage = imaging.AdjustContrast(srcImage, 20) // Increase image contrast by 20%.
          

          func AdjustFunc

          func AdjustFunc(img image.Image, fn func(c color.NRGBA) color.NRGBA) *image.NRGBA

            AdjustFunc applies the fn function to each pixel of the img image and returns the adjusted image.

            Example:

            dstImage = imaging.AdjustFunc(
            	srcImage,
            	func(c color.NRGBA) color.NRGBA {
            		// Shift the red channel by 16.
            		r := int(c.R) + 16
            		if r > 255 {
            			r = 255
            		}
            		return color.NRGBA{uint8(r), c.G, c.B, c.A}
            	}
            )
            

            func AdjustGamma

            func AdjustGamma(img image.Image, gamma float64) *image.NRGBA

              AdjustGamma performs a gamma correction on the image and returns the adjusted image. Gamma parameter must be positive. Gamma = 1.0 gives the original image. Gamma less than 1.0 darkens the image and gamma greater than 1.0 lightens it.

              Example:

              dstImage = imaging.AdjustGamma(srcImage, 0.7)
              

              func AdjustSaturation

              func AdjustSaturation(img image.Image, percentage float64) *image.NRGBA

                AdjustSaturation changes the saturation of the image using the percentage parameter and returns the adjusted image. The percentage must be in the range (-100, 100). The percentage = 0 gives the original image. The percentage = 100 gives the image with the saturation value doubled for each pixel. The percentage = -100 gives the image with the saturation value zeroed for each pixel (grayscale).

                Examples:

                dstImage = imaging.AdjustSaturation(srcImage, 25) // Increase image saturation by 25%.
                dstImage = imaging.AdjustSaturation(srcImage, -10) // Decrease image saturation by 10%.
                

                func AdjustSigmoid

                func AdjustSigmoid(img image.Image, midpoint, factor float64) *image.NRGBA

                  AdjustSigmoid changes the contrast of the image using a sigmoidal function and returns the adjusted image. It's a non-linear contrast change useful for photo adjustments as it preserves highlight and shadow detail. The midpoint parameter is the midpoint of contrast that must be between 0 and 1, typically 0.5. The factor parameter indicates how much to increase or decrease the contrast, typically in range (-10, 10). If the factor parameter is positive the image contrast is increased otherwise the contrast is decreased.

                  Examples:

                  dstImage = imaging.AdjustSigmoid(srcImage, 0.5, 3.0) // Increase the contrast.
                  dstImage = imaging.AdjustSigmoid(srcImage, 0.5, -3.0) // Decrease the contrast.
                  

                  func Blur

                  func Blur(img image.Image, sigma float64) *image.NRGBA

                    Blur produces a blurred version of the image using a Gaussian function. Sigma parameter must be positive and indicates how much the image will be blurred.

                    Example:

                    dstImage := imaging.Blur(srcImage, 3.5)
                    

                    func Clone

                    func Clone(img image.Image) *image.NRGBA

                      Clone returns a copy of the given image.

                      func Convolve3x3

                      func Convolve3x3(img image.Image, kernel [9]float64, options *ConvolveOptions) *image.NRGBA

                        Convolve3x3 convolves the image with the specified 3x3 convolution kernel. Default parameters are used if a nil *ConvolveOptions is passed.

                        func Convolve5x5

                        func Convolve5x5(img image.Image, kernel [25]float64, options *ConvolveOptions) *image.NRGBA

                          Convolve5x5 convolves the image with the specified 5x5 convolution kernel. Default parameters are used if a nil *ConvolveOptions is passed.

                          func Crop

                          func Crop(img image.Image, rect image.Rectangle) *image.NRGBA

                            Crop cuts out a rectangular region with the specified bounds from the image and returns the cropped image.

                            func CropAnchor

                            func CropAnchor(img image.Image, width, height int, anchor Anchor) *image.NRGBA

                              CropAnchor cuts out a rectangular region with the specified size from the image using the specified anchor point and returns the cropped image.

                              func CropCenter

                              func CropCenter(img image.Image, width, height int) *image.NRGBA

                                CropCenter cuts out a rectangular region with the specified size from the center of the image and returns the cropped image.

                                func Decode

                                func Decode(r io.Reader, opts ...DecodeOption) (image.Image, error)

                                  Decode reads an image from r.

                                  func Encode

                                  func Encode(w io.Writer, img image.Image, format Format, opts ...EncodeOption) error

                                    Encode writes the image img to w in the specified format (JPEG, PNG, GIF, TIFF or BMP).

                                    func Fill

                                    func Fill(img image.Image, width, height int, anchor Anchor, filter ResampleFilter) *image.NRGBA

                                      Fill creates an image with the specified dimensions and fills it with the scaled source image. To achieve the correct aspect ratio without stretching, the source image will be cropped.

                                      Example:

                                      dstImage := imaging.Fill(srcImage, 800, 600, imaging.Center, imaging.Lanczos)
                                      

                                      func Fit

                                      func Fit(img image.Image, width, height int, filter ResampleFilter) *image.NRGBA

                                        Fit scales down the image using the specified resample filter to fit the specified maximum width and height and returns the transformed image.

                                        Example:

                                        dstImage := imaging.Fit(srcImage, 800, 600, imaging.Lanczos)
                                        

                                        func FlipH

                                        func FlipH(img image.Image) *image.NRGBA

                                          FlipH flips the image horizontally (from left to right) and returns the transformed image.

                                          func FlipV

                                          func FlipV(img image.Image) *image.NRGBA

                                            FlipV flips the image vertically (from top to bottom) and returns the transformed image.

                                            func Grayscale

                                            func Grayscale(img image.Image) *image.NRGBA

                                              Grayscale produces a grayscale version of the image.

                                              func Histogram

                                              func Histogram(img image.Image) [256]float64

                                                Histogram returns a normalized histogram of an image.

                                                Resulting histogram is represented as an array of 256 floats, where histogram[i] is a probability of a pixel being of a particular luminance i.

                                                func Invert

                                                func Invert(img image.Image) *image.NRGBA

                                                  Invert produces an inverted (negated) version of the image.

                                                  func New

                                                  func New(width, height int, fillColor color.Color) *image.NRGBA

                                                    New creates a new image with the specified width and height, and fills it with the specified color.

                                                    func Open

                                                    func Open(filename string, opts ...DecodeOption) (image.Image, error)

                                                      Open loads an image from file.

                                                      Examples:

                                                      // Load an image from file.
                                                      img, err := imaging.Open("test.jpg")
                                                      
                                                      // Load an image and transform it depending on the EXIF orientation tag (if present).
                                                      img, err := imaging.Open("test.jpg", imaging.AutoOrientation(true))
                                                      

                                                      func Overlay

                                                      func Overlay(background, img image.Image, pos image.Point, opacity float64) *image.NRGBA

                                                        Overlay draws the img image over the background image at given position and returns the combined image. Opacity parameter is the opacity of the img image layer, used to compose the images, it must be from 0.0 to 1.0.

                                                        Examples:

                                                        // Draw spriteImage over backgroundImage at the given position (x=50, y=50).
                                                        dstImage := imaging.Overlay(backgroundImage, spriteImage, image.Pt(50, 50), 1.0)
                                                        
                                                        // Blend two opaque images of the same size.
                                                        dstImage := imaging.Overlay(imageOne, imageTwo, image.Pt(0, 0), 0.5)
                                                        

                                                        func OverlayCenter

                                                        func OverlayCenter(background, img image.Image, opacity float64) *image.NRGBA

                                                          OverlayCenter overlays the img image to the center of the background image and returns the combined image. Opacity parameter is the opacity of the img image layer, used to compose the images, it must be from 0.0 to 1.0.

                                                          func Paste

                                                          func Paste(background, img image.Image, pos image.Point) *image.NRGBA

                                                            Paste pastes the img image to the background image at the specified position and returns the combined image.

                                                            func PasteCenter

                                                            func PasteCenter(background, img image.Image) *image.NRGBA

                                                              PasteCenter pastes the img image to the center of the background image and returns the combined image.

                                                              func Resize

                                                              func Resize(img image.Image, width, height int, filter ResampleFilter) *image.NRGBA

                                                                Resize resizes the image to the specified width and height using the specified resampling filter and returns the transformed image. If one of width or height is 0, the image aspect ratio is preserved.

                                                                Example:

                                                                dstImage := imaging.Resize(srcImage, 800, 600, imaging.Lanczos)
                                                                

                                                                func Rotate

                                                                func Rotate(img image.Image, angle float64, bgColor color.Color) *image.NRGBA

                                                                  Rotate rotates an image by the given angle counter-clockwise . The angle parameter is the rotation angle in degrees. The bgColor parameter specifies the color of the uncovered zone after the rotation.

                                                                  func Rotate180

                                                                  func Rotate180(img image.Image) *image.NRGBA

                                                                    Rotate180 rotates the image 180 degrees counter-clockwise and returns the transformed image.

                                                                    func Rotate270

                                                                    func Rotate270(img image.Image) *image.NRGBA

                                                                      Rotate270 rotates the image 270 degrees counter-clockwise and returns the transformed image.

                                                                      func Rotate90

                                                                      func Rotate90(img image.Image) *image.NRGBA

                                                                        Rotate90 rotates the image 90 degrees counter-clockwise and returns the transformed image.

                                                                        func Save

                                                                        func Save(img image.Image, filename string, opts ...EncodeOption) (err error)

                                                                          Save saves the image to file with the specified filename. The format is determined from the filename extension: "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.

                                                                          Examples:

                                                                          // Save the image as PNG.
                                                                          err := imaging.Save(img, "out.png")
                                                                          
                                                                          // Save the image as JPEG with optional quality parameter set to 80.
                                                                          err := imaging.Save(img, "out.jpg", imaging.JPEGQuality(80))
                                                                          

                                                                          func Sharpen

                                                                          func Sharpen(img image.Image, sigma float64) *image.NRGBA

                                                                            Sharpen produces a sharpened version of the image. Sigma parameter must be positive and indicates how much the image will be sharpened.

                                                                            Example:

                                                                            dstImage := imaging.Sharpen(srcImage, 3.5)
                                                                            

                                                                            func Thumbnail

                                                                            func Thumbnail(img image.Image, width, height int, filter ResampleFilter) *image.NRGBA

                                                                              Thumbnail scales the image up or down using the specified resample filter, crops it to the specified width and hight and returns the transformed image.

                                                                              Example:

                                                                              dstImage := imaging.Thumbnail(srcImage, 100, 100, imaging.Lanczos)
                                                                              

                                                                              func Transpose

                                                                              func Transpose(img image.Image) *image.NRGBA

                                                                                Transpose flips the image horizontally and rotates 90 degrees counter-clockwise.

                                                                                func Transverse

                                                                                func Transverse(img image.Image) *image.NRGBA

                                                                                  Transverse flips the image vertically and rotates 90 degrees counter-clockwise.

                                                                                  Types

                                                                                  type Anchor

                                                                                  type Anchor int

                                                                                    Anchor is the anchor point for image alignment.

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

                                                                                      Anchor point positions.

                                                                                      type ConvolveOptions

                                                                                      type ConvolveOptions struct {
                                                                                      	// If Normalize is true the kernel is normalized before convolution.
                                                                                      	Normalize bool
                                                                                      
                                                                                      	// If Abs is true the absolute value of each color channel is taken after convolution.
                                                                                      	Abs bool
                                                                                      
                                                                                      	// Bias is added to each color channel value after convolution.
                                                                                      	Bias int
                                                                                      }

                                                                                        ConvolveOptions are convolution parameters.

                                                                                        type DecodeOption

                                                                                        type DecodeOption func(*decodeConfig)

                                                                                          DecodeOption sets an optional parameter for the Decode and Open functions.

                                                                                          func AutoOrientation

                                                                                          func AutoOrientation(enabled bool) DecodeOption

                                                                                            AutoOrientation returns a DecodeOption that sets the auto-orientation mode. If auto-orientation is enabled, the image will be transformed after decoding according to the EXIF orientation tag (if present). By default it's disabled.

                                                                                            type EncodeOption

                                                                                            type EncodeOption func(*encodeConfig)

                                                                                              EncodeOption sets an optional parameter for the Encode and Save functions.

                                                                                              func GIFDrawer

                                                                                              func GIFDrawer(drawer draw.Drawer) EncodeOption

                                                                                                GIFDrawer returns an EncodeOption that sets the drawer that is used to convert the source image to the desired palette of the GIF-encoded image.

                                                                                                func GIFNumColors

                                                                                                func GIFNumColors(numColors int) EncodeOption

                                                                                                  GIFNumColors returns an EncodeOption that sets the maximum number of colors used in the GIF-encoded image. It ranges from 1 to 256. Default is 256.

                                                                                                  func GIFQuantizer

                                                                                                  func GIFQuantizer(quantizer draw.Quantizer) EncodeOption

                                                                                                    GIFQuantizer returns an EncodeOption that sets the quantizer that is used to produce a palette of the GIF-encoded image.

                                                                                                    func JPEGQuality

                                                                                                    func JPEGQuality(quality int) EncodeOption

                                                                                                      JPEGQuality returns an EncodeOption that sets the output JPEG quality. Quality ranges from 1 to 100 inclusive, higher is better. Default is 95.

                                                                                                      func PNGCompressionLevel

                                                                                                      func PNGCompressionLevel(level png.CompressionLevel) EncodeOption

                                                                                                        PNGCompressionLevel returns an EncodeOption that sets the compression level of the PNG-encoded image. Default is png.DefaultCompression.

                                                                                                        type Format

                                                                                                        type Format int

                                                                                                          Format is an image file format.

                                                                                                          const (
                                                                                                          	JPEG Format = iota
                                                                                                          	PNG
                                                                                                          	GIF
                                                                                                          	TIFF
                                                                                                          	BMP
                                                                                                          )

                                                                                                            Image file formats.

                                                                                                            func FormatFromExtension

                                                                                                            func FormatFromExtension(ext string) (Format, error)

                                                                                                              FormatFromExtension parses image format from filename extension: "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.

                                                                                                              func FormatFromFilename

                                                                                                              func FormatFromFilename(filename string) (Format, error)

                                                                                                                FormatFromFilename parses image format from filename: "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.

                                                                                                                func (Format) String

                                                                                                                func (f Format) String() string

                                                                                                                type ResampleFilter

                                                                                                                type ResampleFilter struct {
                                                                                                                	Support float64
                                                                                                                	Kernel  func(float64) float64
                                                                                                                }

                                                                                                                  ResampleFilter specifies a resampling filter to be used for image resizing.

                                                                                                                  General filter recommendations:
                                                                                                                  
                                                                                                                  - 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 a 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.
                                                                                                                  
                                                                                                                  var BSpline ResampleFilter

                                                                                                                    BSpline is a smooth cubic filter (BC-spline; B=1; C=0).

                                                                                                                    var Bartlett ResampleFilter

                                                                                                                      Bartlett is a Bartlett-windowed sinc filter (3 lobes).

                                                                                                                      var Blackman ResampleFilter

                                                                                                                        Blackman is a Blackman-windowed sinc filter (3 lobes).

                                                                                                                        var Box ResampleFilter

                                                                                                                          Box filter (averaging pixels).

                                                                                                                          var CatmullRom ResampleFilter

                                                                                                                            CatmullRom is a Catmull-Rom - sharp cubic filter (BC-spline; B=0; C=0.5).

                                                                                                                            var Cosine ResampleFilter

                                                                                                                              Cosine is a Cosine-windowed sinc filter (3 lobes).

                                                                                                                              var Gaussian ResampleFilter

                                                                                                                                Gaussian is a Gaussian blurring filter.

                                                                                                                                var Hamming ResampleFilter

                                                                                                                                  Hamming is a Hamming-windowed sinc filter (3 lobes).

                                                                                                                                  var Hann ResampleFilter

                                                                                                                                    Hann is a Hann-windowed sinc filter (3 lobes).

                                                                                                                                    var Hermite ResampleFilter

                                                                                                                                      Hermite cubic spline filter (BC-spline; B=0; C=0).

                                                                                                                                      var Lanczos ResampleFilter

                                                                                                                                        Lanczos filter (3 lobes).

                                                                                                                                        var Linear ResampleFilter

                                                                                                                                          Linear filter.

                                                                                                                                          var MitchellNetravali ResampleFilter

                                                                                                                                            MitchellNetravali is Mitchell-Netravali cubic filter (BC-spline; B=1/3; C=1/3).

                                                                                                                                            var NearestNeighbor ResampleFilter

                                                                                                                                              NearestNeighbor is a nearest-neighbor filter (no anti-aliasing).

                                                                                                                                              var Welch ResampleFilter

                                                                                                                                                Welch is a Welch-windowed sinc filter (parabolic window, 3 lobes).