Add SetScaleStyle for zoomed images

context.go

@@ -77,6 +77,7 @@ type Context struct {
  fontHeight float64
  matrix Matrix
  stack []*Context
+ scaleStyle ScaleStyle
 }
 
 // NewContext creates a new image.RGBA with the specified width and height
@@ -112,6 +113,76 @@ func NewContextForRGBA(im *image.RGBA) *Context {
  }
 }
 
+// ScaleStyle determines the way image pixels are interpolated when scaled.
+// See
+// https://pkg.go.dev/golang.org/x/image/draw
+// for the corresponding interpolators.
+type ScaleStyle int
+
+const (
+ // BiLinear is the tent kernel. It is slow, but usually gives high quality
+ // results.
+ BiLinear ScaleStyle = iota
+
+ // ApproxBiLinear is a mixture of the nearest neighbor and bi-linear
+ // interpolators. It is fast, but usually gives medium quality results.
+ //
+ // It implements bi-linear interpolation when upscaling and a bi-linear
+ // blend of the 4 nearest neighbor pixels when downscaling. This yields
+ // nicer quality than nearest neighbor interpolation when upscaling, but
+ // the time taken is independent of the number of source pixels, unlike the
+ // bi-linear interpolator. When downscaling a large image, the performance
+ // difference can be significant.
+ ApproxBiLinear
+
+ // NearestNeighbor is the nearest neighbor interpolator. It is very fast,
+ // but usually gives very low quality results. When scaling up, the result
+ // will look 'blocky'.
+ NearestNeighbor
+
+ // CatmullRom is the Catmull-Rom kernel. It is very slow, but usually gives
+ // very high quality results.
+ //
+ // It is an instance of the more general cubic BC-spline kernel with parameters
+ // B=0 and C=0.5. See Mitchell and Netravali, "Reconstruction Filters in
+ // Computer Graphics", Computer Graphics, Vol. 22, No. 4, pp. 221-228.
+ CatmullRom
+)
+
+func (s ScaleStyle) transformer() draw.Interpolator {
+ switch s {
+ case BiLinear:
+ return draw.BiLinear
+ case ApproxBiLinear:
+ return draw.ApproxBiLinear
+ case NearestNeighbor:
+ return draw.NearestNeighbor
+ case CatmullRom:
+ return draw.CatmullRom
+ }
+ return draw.BiLinear // BiLinear by default.
+}
+
+func (dc *Context) SetScaleStyle(s ScaleStyle) {
+ dc.scaleStyle = s
+}
+
+func (dc *Context) SetScaleBiLinear() {
+ dc.SetScaleStyle(BiLinear)
+}
+
+func (dc *Context) SetScaleApproxBiLinear() {
+ dc.SetScaleStyle(ApproxBiLinear)
+}
+
+func (dc *Context) SetScaleNearestNeighbor() {
+ dc.SetScaleStyle(NearestNeighbor)
+}
+
+func (dc *Context) SetScaleCatmullRom() {
+ dc.SetScaleStyle(CatmullRom)
+}
+
 // GetCurrentPoint will return the current point and if there is a current point.
 // The point will have been transformed by the context's transformation matrix.
 func (dc *Context) GetCurrentPoint() (Point, bool) {
@@ -673,7 +744,7 @@ func (dc *Context) DrawImageAnchored(im image.Image, x, y int, ax, ay float64) {
  s := im.Bounds().Size()
  x -= int(ax * float64(s.X))
  y -= int(ay * float64(s.Y))
- transformer := draw.BiLinear
+ transformer := dc.scaleStyle.transformer()
  fx, fy := float64(x), float64(y)
  m := dc.matrix.Translate(fx, fy)
  s2d := f64.Aff3{m.XX, m.XY, m.X0, m.YX, m.YY, m.Y0}