From 2c27a34d37e7d9e67f9588e0000b4dc59a6b2233 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Tue, 3 Mar 2015 16:54:53 +1100 Subject: [PATCH] draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike --- draw/gen.go | 78 +++++----- draw/impl.go | 373 +++++++++++++++++++++++++-------------------- draw/scale.go | 67 ++++---- draw/scale_test.go | 19 ++- 4 files changed, 287 insertions(+), 250 deletions(-) diff --git a/draw/gen.go b/draw/gen.go index 06080d8..a16bf84 100644 --- a/draw/gen.go +++ b/draw/gen.go @@ -26,8 +26,8 @@ func main() { w.WriteString("// generated by \"go run gen.go\". DO NOT EDIT.\n\n" + "package draw\n\nimport (\n\"image\"\n\"image/color\"\n)\n") - gen(w, "nnScaler", codeNNLeaf) - gen(w, "ablScaler", codeABLLeaf) + gen(w, "nnInterpolator", codeNNLeaf) + gen(w, "ablInterpolator", codeABLLeaf) genKernel(w) if *debug { @@ -181,7 +181,7 @@ func expnDollar(prefix, dollar, suffix string, d *data) string { default: return ";" case "*image.RGBA": - return "d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))" + return "d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))" } case "preKernelInner": @@ -189,7 +189,7 @@ func expnDollar(prefix, dollar, suffix string, d *data) string { default: return ";" case "*image.RGBA": - return "d := dst.PixOffset(dp.X+int(dx), dp.Y+adr.Min.Y)" + return "d := dst.PixOffset(dr.Min.X+int(dx), dr.Min.Y+adr.Min.Y)" } case "blend": @@ -222,7 +222,7 @@ func expnDollar(prefix, dollar, suffix string, d *data) string { "dstColorRGBA64.G = uint16(%sg)\n"+ "dstColorRGBA64.B = uint16(%sb)\n"+ "dstColorRGBA64.A = uint16(%sa)\n"+ - "dst.Set(dp.X+int(%s), dp.Y+int(%s), dstColor)", + "dst.Set(dr.Min.X+int(%s), dr.Min.Y+int(%s), dstColor)", args[2], args[2], args[2], args[2], args[0], args[1], ) @@ -251,7 +251,7 @@ func expnDollar(prefix, dollar, suffix string, d *data) string { "dstColorRGBA64.G = ftou(%sg * %s)\n"+ "dstColorRGBA64.B = ftou(%sb * %s)\n"+ "dstColorRGBA64.A = ftou(%sa * %s)\n"+ - "dst.Set(dp.X+int(%s), dp.Y+int(%s), dstColor)", + "dst.Set(dr.Min.X+int(%s), dr.Min.Y+int(%s), dstColor)", args[2], args[3], args[2], args[3], args[2], args[3], args[2], args[3], args[0], args[1], ) @@ -287,14 +287,14 @@ func expnDollar(prefix, dollar, suffix string, d *data) string { log.Fatalf("bad sType %q", d.sType) case "image.Image", "*image.Gray", "*image.NRGBA", "*image.Uniform", "*image.YCbCr": // TODO: separate code for concrete types. fmt.Fprintf(buf, "%sr%s, %sg%s, %sb%s, %sa%s := "+ - "src.At(sp.X + int(%s), sp.Y+int(%s)).RGBA()\n", + "src.At(sr.Min.X + int(%s), sr.Min.Y+int(%s)).RGBA()\n", lhs, tmp, lhs, tmp, lhs, tmp, lhs, tmp, args[0], args[1], ) case "*image.RGBA": // TODO: there's no need to multiply by 0x101 if the next thing // we're going to do is shift right by 8. - fmt.Fprintf(buf, "%si := src.PixOffset(sp.X + int(%s), sp.Y+int(%s))\n"+ + fmt.Fprintf(buf, "%si := src.PixOffset(sr.Min.X + int(%s), sr.Min.Y+int(%s))\n"+ "%sr%s := uint32(src.Pix[%si+0]) * 0x101\n"+ "%sg%s := uint32(src.Pix[%si+1]) * 0x101\n"+ "%sb%s := uint32(src.Pix[%si+2]) * 0x101\n"+ @@ -407,34 +407,35 @@ func relName(s string) string { const ( codeRoot = ` - func (z *$receiver) Scale(dst Image, dp image.Point, src image.Image, sp image.Point) { - if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 { - return - } - // adr is the affected destination pixels, relative to dp. - adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}}) - if adr.Empty() { + func (z $receiver) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle) { + // adr is the affected destination pixels, relative to dr.Min. + adr := dst.Bounds().Intersect(dr).Sub(dr.Min) + if adr.Empty() || sr.Empty() { return } // sr is the source pixels. If it extends beyond the src bounds, // we cannot use the type-specific fast paths, as they access // the Pix fields directly without bounds checking. - if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) { - z.scale_Image_Image(dst, dp, adr, src, sp) + if !sr.In(src.Bounds()) { + z.scale_Image_Image(dst, dr, adr, src, sr) } else { - $switch z.scale_$dTypeRN_$sTypeRN(dst, dp, adr, src, sp) + $switch z.scale_$dTypeRN_$sTypeRN(dst, dr, adr, src, sr) } } ` codeNNLeaf = ` - func (z *nnScaler) scale_$dTypeRN_$sTypeRN(dst $dType, dp image.Point, adr image.Rectangle, src $sType, sp image.Point) { + func (nnInterpolator) scale_$dTypeRN_$sTypeRN(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) $preOuter for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) + sy := (2*uint64(dy) + 1) * sh / dh2 $preInner for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) + sx := (2*uint64(dx) + 1) * sw / dw2 p := $srcu[sx, sy] $outputu[dx, dy, p] } @@ -443,9 +444,11 @@ const ( ` codeABLLeaf = ` - func (z *ablScaler) scale_$dTypeRN_$sTypeRN(dst $dType, dp image.Point, adr image.Rectangle, src $sType, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) + func (ablInterpolator) scale_$dTypeRN_$sTypeRN(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) $preOuter for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { sy := (float64(dy)+0.5)*yscale - 0.5 @@ -456,7 +459,7 @@ const ( if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } @@ -470,7 +473,7 @@ const ( if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } @@ -488,13 +491,14 @@ const ( ` codeKernelRoot = ` - func (z *kernelScaler) Scale(dst Image, dp image.Point, src image.Image, sp image.Point) { - if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 { + func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle) { + if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) { + z.kernel.Scale(dst, dr, src, sr) return } - // adr is the affected destination pixels, relative to dp. - adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}}) - if adr.Empty() { + // adr is the affected destination pixels, relative to dr.Min. + adr := dst.Bounds().Intersect(dr).Sub(dr.Min) + if adr.Empty() || sr.Empty() { return } // Create a temporary buffer: @@ -506,18 +510,18 @@ const ( // sr is the source pixels. If it extends beyond the src bounds, // we cannot use the type-specific fast paths, as they access // the Pix fields directly without bounds checking. - if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) { - z.scaleX_Image(tmp, src, sp) + if !sr.In(src.Bounds()) { + z.scaleX_Image(tmp, src, sr) } else { - $switchS z.scaleX_$sTypeRN(tmp, src, sp) + $switchS z.scaleX_$sTypeRN(tmp, src, sr) } - $switchD z.scaleY_$dTypeRN(dst, dp, adr, tmp) + $switchD z.scaleY_$dTypeRN(dst, dr, adr, tmp) } ` codeKernelLeafX = ` - func (z *kernelScaler) scaleX_$sTypeRN(tmp [][4]float64, src $sType, sp image.Point) { + func (z *kernelScaler) scaleX_$sTypeRN(tmp [][4]float64, src $sType, sr image.Rectangle) { t := 0 for y := int32(0); y < z.sh; y++ { for _, s := range z.horizontal.sources { @@ -538,7 +542,7 @@ const ( ` codeKernelLeafY = ` - func (z *kernelScaler) scaleY_$dTypeRN(dst $dType, dp image.Point, adr image.Rectangle, tmp [][4]float64) { + func (z *kernelScaler) scaleY_$dTypeRN(dst $dType, dr, adr image.Rectangle, tmp [][4]float64) { $preOuter for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $preKernelInner diff --git a/draw/impl.go b/draw/impl.go index ccc0632..7a0a5bb 100644 --- a/draw/impl.go +++ b/draw/impl.go @@ -7,53 +7,54 @@ import ( "image/color" ) -func (z *nnScaler) Scale(dst Image, dp image.Point, src image.Image, sp image.Point) { - if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 { - return - } - // adr is the affected destination pixels, relative to dp. - adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}}) - if adr.Empty() { +func (z nnInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle) { + // adr is the affected destination pixels, relative to dr.Min. + adr := dst.Bounds().Intersect(dr).Sub(dr.Min) + if adr.Empty() || sr.Empty() { return } // sr is the source pixels. If it extends beyond the src bounds, // we cannot use the type-specific fast paths, as they access // the Pix fields directly without bounds checking. - if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) { - z.scale_Image_Image(dst, dp, adr, src, sp) + if !sr.In(src.Bounds()) { + z.scale_Image_Image(dst, dr, adr, src, sr) } else { switch dst := dst.(type) { case *image.RGBA: switch src := src.(type) { case *image.Gray: - z.scale_RGBA_Gray(dst, dp, adr, src, sp) + z.scale_RGBA_Gray(dst, dr, adr, src, sr) case *image.NRGBA: - z.scale_RGBA_NRGBA(dst, dp, adr, src, sp) + z.scale_RGBA_NRGBA(dst, dr, adr, src, sr) case *image.RGBA: - z.scale_RGBA_RGBA(dst, dp, adr, src, sp) + z.scale_RGBA_RGBA(dst, dr, adr, src, sr) case *image.Uniform: - z.scale_RGBA_Uniform(dst, dp, adr, src, sp) + z.scale_RGBA_Uniform(dst, dr, adr, src, sr) case *image.YCbCr: - z.scale_RGBA_YCbCr(dst, dp, adr, src, sp) + z.scale_RGBA_YCbCr(dst, dr, adr, src, sr) default: - z.scale_RGBA_Image(dst, dp, adr, src, sp) + z.scale_RGBA_Image(dst, dr, adr, src, sr) } default: switch src := src.(type) { default: - z.scale_Image_Image(dst, dp, adr, src, sp) + z.scale_Image_Image(dst, dr, adr, src, sr) } } } } -func (z *nnScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Gray, sp image.Point) { +func (nnInterpolator) scale_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + sy := (2*uint64(dy) + 1) * sh / dh2 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) - pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA() + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() dst.Pix[d+0] = uint8(uint32(pr) >> 8) dst.Pix[d+1] = uint8(uint32(pg) >> 8) dst.Pix[d+2] = uint8(uint32(pb) >> 8) @@ -63,13 +64,17 @@ func (z *nnScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.Re } } -func (z *nnScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.NRGBA, sp image.Point) { +func (nnInterpolator) scale_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + sy := (2*uint64(dy) + 1) * sh / dh2 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) - pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA() + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() dst.Pix[d+0] = uint8(uint32(pr) >> 8) dst.Pix[d+1] = uint8(uint32(pg) >> 8) dst.Pix[d+2] = uint8(uint32(pb) >> 8) @@ -79,13 +84,17 @@ func (z *nnScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image.R } } -func (z *nnScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.RGBA, sp image.Point) { +func (nnInterpolator) scale_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + sy := (2*uint64(dy) + 1) * sh / dh2 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) - pi := src.PixOffset(sp.X+int(sx), sp.Y+int(sy)) + sx := (2*uint64(dx) + 1) * sw / dw2 + pi := src.PixOffset(sr.Min.X+int(sx), sr.Min.Y+int(sy)) pr := uint32(src.Pix[pi+0]) * 0x101 pg := uint32(src.Pix[pi+1]) * 0x101 pb := uint32(src.Pix[pi+2]) * 0x101 @@ -99,13 +108,17 @@ func (z *nnScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.Re } } -func (z *nnScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Uniform, sp image.Point) { +func (nnInterpolator) scale_RGBA_Uniform(dst *image.RGBA, dr, adr image.Rectangle, src *image.Uniform, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + sy := (2*uint64(dy) + 1) * sh / dh2 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) - pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA() + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() dst.Pix[d+0] = uint8(uint32(pr) >> 8) dst.Pix[d+1] = uint8(uint32(pg) >> 8) dst.Pix[d+2] = uint8(uint32(pb) >> 8) @@ -115,13 +128,17 @@ func (z *nnScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr image } } -func (z *nnScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.YCbCr, sp image.Point) { +func (nnInterpolator) scale_RGBA_YCbCr(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + sy := (2*uint64(dy) + 1) * sh / dh2 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) - pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA() + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() dst.Pix[d+0] = uint8(uint32(pr) >> 8) dst.Pix[d+1] = uint8(uint32(pg) >> 8) dst.Pix[d+2] = uint8(uint32(pb) >> 8) @@ -131,13 +148,17 @@ func (z *nnScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image.R } } -func (z *nnScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) { +func (nnInterpolator) scale_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + sy := (2*uint64(dy) + 1) * sh / dh2 + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) - pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA() + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() dst.Pix[d+0] = uint8(uint32(pr) >> 8) dst.Pix[d+1] = uint8(uint32(pg) >> 8) dst.Pix[d+2] = uint8(uint32(pb) >> 8) @@ -147,66 +168,69 @@ func (z *nnScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image.R } } -func (z *nnScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) { +func (nnInterpolator) scale_Image_Image(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) { + dw2 := uint64(dr.Dx()) * 2 + dh2 := uint64(dr.Dy()) * 2 + sw := uint64(sr.Dx()) + sh := uint64(sr.Dy()) dstColorRGBA64 := &color.RGBA64{} dstColor := color.Color(dstColorRGBA64) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh)) + sy := (2*uint64(dy) + 1) * sh / dh2 for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw)) - pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA() + sx := (2*uint64(dx) + 1) * sw / dw2 + pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() dstColorRGBA64.R = uint16(pr) dstColorRGBA64.G = uint16(pg) dstColorRGBA64.B = uint16(pb) dstColorRGBA64.A = uint16(pa) - dst.Set(dp.X+int(dx), dp.Y+int(dy), dstColor) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) } } } -func (z *ablScaler) Scale(dst Image, dp image.Point, src image.Image, sp image.Point) { - if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 { - return - } - // adr is the affected destination pixels, relative to dp. - adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}}) - if adr.Empty() { +func (z ablInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle) { + // adr is the affected destination pixels, relative to dr.Min. + adr := dst.Bounds().Intersect(dr).Sub(dr.Min) + if adr.Empty() || sr.Empty() { return } // sr is the source pixels. If it extends beyond the src bounds, // we cannot use the type-specific fast paths, as they access // the Pix fields directly without bounds checking. - if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) { - z.scale_Image_Image(dst, dp, adr, src, sp) + if !sr.In(src.Bounds()) { + z.scale_Image_Image(dst, dr, adr, src, sr) } else { switch dst := dst.(type) { case *image.RGBA: switch src := src.(type) { case *image.Gray: - z.scale_RGBA_Gray(dst, dp, adr, src, sp) + z.scale_RGBA_Gray(dst, dr, adr, src, sr) case *image.NRGBA: - z.scale_RGBA_NRGBA(dst, dp, adr, src, sp) + z.scale_RGBA_NRGBA(dst, dr, adr, src, sr) case *image.RGBA: - z.scale_RGBA_RGBA(dst, dp, adr, src, sp) + z.scale_RGBA_RGBA(dst, dr, adr, src, sr) case *image.Uniform: - z.scale_RGBA_Uniform(dst, dp, adr, src, sp) + z.scale_RGBA_Uniform(dst, dr, adr, src, sr) case *image.YCbCr: - z.scale_RGBA_YCbCr(dst, dp, adr, src, sp) + z.scale_RGBA_YCbCr(dst, dr, adr, src, sr) default: - z.scale_RGBA_Image(dst, dp, adr, src, sp) + z.scale_RGBA_Image(dst, dr, adr, src, sr) } default: switch src := src.(type) { default: - z.scale_Image_Image(dst, dp, adr, src, sp) + z.scale_Image_Image(dst, dr, adr, src, sr) } } } } -func (z *ablScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Gray, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) +func (ablInterpolator) scale_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { sy := (float64(dy)+0.5)*yscale - 0.5 sy0 := int32(sy) @@ -216,11 +240,11 @@ func (z *ablScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.R if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { sx := (float64(dx)+0.5)*xscale - 0.5 sx0 := int32(sx) @@ -230,16 +254,16 @@ func (z *ablScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.R if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } - s00ru, s00gu, s00bu, s00au := src.At(sp.X+int(sx0), sp.Y+int(sy0)).RGBA() + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() s00r := float64(s00ru) s00g := float64(s00gu) s00b := float64(s00bu) s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sp.X+int(sx1), sp.Y+int(sy0)).RGBA() + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() s10r := float64(s10ru) s10g := float64(s10gu) s10b := float64(s10bu) @@ -248,12 +272,12 @@ func (z *ablScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.R s10g = xFrac1*s00g + xFrac0*s10g s10b = xFrac1*s00b + xFrac0*s10b s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sp.X+int(sx0), sp.Y+int(sy1)).RGBA() + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() s01r := float64(s01ru) s01g := float64(s01gu) s01b := float64(s01bu) s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sp.X+int(sx1), sp.Y+int(sy1)).RGBA() + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() s11r := float64(s11ru) s11g := float64(s11gu) s11b := float64(s11bu) @@ -275,9 +299,11 @@ func (z *ablScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.R } } -func (z *ablScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.NRGBA, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) +func (ablInterpolator) scale_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { sy := (float64(dy)+0.5)*yscale - 0.5 sy0 := int32(sy) @@ -287,11 +313,11 @@ func (z *ablScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image. if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { sx := (float64(dx)+0.5)*xscale - 0.5 sx0 := int32(sx) @@ -301,16 +327,16 @@ func (z *ablScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image. if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } - s00ru, s00gu, s00bu, s00au := src.At(sp.X+int(sx0), sp.Y+int(sy0)).RGBA() + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() s00r := float64(s00ru) s00g := float64(s00gu) s00b := float64(s00bu) s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sp.X+int(sx1), sp.Y+int(sy0)).RGBA() + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() s10r := float64(s10ru) s10g := float64(s10gu) s10b := float64(s10bu) @@ -319,12 +345,12 @@ func (z *ablScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image. s10g = xFrac1*s00g + xFrac0*s10g s10b = xFrac1*s00b + xFrac0*s10b s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sp.X+int(sx0), sp.Y+int(sy1)).RGBA() + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() s01r := float64(s01ru) s01g := float64(s01gu) s01b := float64(s01bu) s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sp.X+int(sx1), sp.Y+int(sy1)).RGBA() + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() s11r := float64(s11ru) s11g := float64(s11gu) s11b := float64(s11bu) @@ -346,9 +372,11 @@ func (z *ablScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image. } } -func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.RGBA, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) +func (ablInterpolator) scale_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { sy := (float64(dy)+0.5)*yscale - 0.5 sy0 := int32(sy) @@ -358,11 +386,11 @@ func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.R if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { sx := (float64(dx)+0.5)*xscale - 0.5 sx0 := int32(sx) @@ -372,11 +400,11 @@ func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.R if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } - s00i := src.PixOffset(sp.X+int(sx0), sp.Y+int(sy0)) + s00i := src.PixOffset(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)) s00ru := uint32(src.Pix[s00i+0]) * 0x101 s00gu := uint32(src.Pix[s00i+1]) * 0x101 s00bu := uint32(src.Pix[s00i+2]) * 0x101 @@ -385,7 +413,7 @@ func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.R s00g := float64(s00gu) s00b := float64(s00bu) s00a := float64(s00au) - s10i := src.PixOffset(sp.X+int(sx1), sp.Y+int(sy0)) + s10i := src.PixOffset(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)) s10ru := uint32(src.Pix[s10i+0]) * 0x101 s10gu := uint32(src.Pix[s10i+1]) * 0x101 s10bu := uint32(src.Pix[s10i+2]) * 0x101 @@ -398,7 +426,7 @@ func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.R s10g = xFrac1*s00g + xFrac0*s10g s10b = xFrac1*s00b + xFrac0*s10b s10a = xFrac1*s00a + xFrac0*s10a - s01i := src.PixOffset(sp.X+int(sx0), sp.Y+int(sy1)) + s01i := src.PixOffset(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)) s01ru := uint32(src.Pix[s01i+0]) * 0x101 s01gu := uint32(src.Pix[s01i+1]) * 0x101 s01bu := uint32(src.Pix[s01i+2]) * 0x101 @@ -407,7 +435,7 @@ func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.R s01g := float64(s01gu) s01b := float64(s01bu) s01a := float64(s01au) - s11i := src.PixOffset(sp.X+int(sx1), sp.Y+int(sy1)) + s11i := src.PixOffset(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)) s11ru := uint32(src.Pix[s11i+0]) * 0x101 s11gu := uint32(src.Pix[s11i+1]) * 0x101 s11bu := uint32(src.Pix[s11i+2]) * 0x101 @@ -433,9 +461,11 @@ func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.R } } -func (z *ablScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Uniform, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) +func (ablInterpolator) scale_RGBA_Uniform(dst *image.RGBA, dr, adr image.Rectangle, src *image.Uniform, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { sy := (float64(dy)+0.5)*yscale - 0.5 sy0 := int32(sy) @@ -445,11 +475,11 @@ func (z *ablScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr imag if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { sx := (float64(dx)+0.5)*xscale - 0.5 sx0 := int32(sx) @@ -459,16 +489,16 @@ func (z *ablScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr imag if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } - s00ru, s00gu, s00bu, s00au := src.At(sp.X+int(sx0), sp.Y+int(sy0)).RGBA() + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() s00r := float64(s00ru) s00g := float64(s00gu) s00b := float64(s00bu) s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sp.X+int(sx1), sp.Y+int(sy0)).RGBA() + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() s10r := float64(s10ru) s10g := float64(s10gu) s10b := float64(s10bu) @@ -477,12 +507,12 @@ func (z *ablScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr imag s10g = xFrac1*s00g + xFrac0*s10g s10b = xFrac1*s00b + xFrac0*s10b s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sp.X+int(sx0), sp.Y+int(sy1)).RGBA() + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() s01r := float64(s01ru) s01g := float64(s01gu) s01b := float64(s01bu) s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sp.X+int(sx1), sp.Y+int(sy1)).RGBA() + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() s11r := float64(s11ru) s11g := float64(s11gu) s11b := float64(s11bu) @@ -504,9 +534,11 @@ func (z *ablScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr imag } } -func (z *ablScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.YCbCr, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) +func (ablInterpolator) scale_RGBA_YCbCr(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { sy := (float64(dy)+0.5)*yscale - 0.5 sy0 := int32(sy) @@ -516,11 +548,11 @@ func (z *ablScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image. if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { sx := (float64(dx)+0.5)*xscale - 0.5 sx0 := int32(sx) @@ -530,16 +562,16 @@ func (z *ablScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image. if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } - s00ru, s00gu, s00bu, s00au := src.At(sp.X+int(sx0), sp.Y+int(sy0)).RGBA() + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() s00r := float64(s00ru) s00g := float64(s00gu) s00b := float64(s00bu) s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sp.X+int(sx1), sp.Y+int(sy0)).RGBA() + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() s10r := float64(s10ru) s10g := float64(s10gu) s10b := float64(s10bu) @@ -548,12 +580,12 @@ func (z *ablScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image. s10g = xFrac1*s00g + xFrac0*s10g s10b = xFrac1*s00b + xFrac0*s10b s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sp.X+int(sx0), sp.Y+int(sy1)).RGBA() + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() s01r := float64(s01ru) s01g := float64(s01gu) s01b := float64(s01bu) s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sp.X+int(sx1), sp.Y+int(sy1)).RGBA() + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() s11r := float64(s11ru) s11g := float64(s11gu) s11b := float64(s11bu) @@ -575,9 +607,11 @@ func (z *ablScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image. } } -func (z *ablScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) +func (ablInterpolator) scale_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { sy := (float64(dy)+0.5)*yscale - 0.5 sy0 := int32(sy) @@ -587,11 +621,11 @@ func (z *ablScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image. if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } - d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy)) + d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy)) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { sx := (float64(dx)+0.5)*xscale - 0.5 sx0 := int32(sx) @@ -601,16 +635,16 @@ func (z *ablScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image. if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } - s00ru, s00gu, s00bu, s00au := src.At(sp.X+int(sx0), sp.Y+int(sy0)).RGBA() + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() s00r := float64(s00ru) s00g := float64(s00gu) s00b := float64(s00bu) s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sp.X+int(sx1), sp.Y+int(sy0)).RGBA() + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() s10r := float64(s10ru) s10g := float64(s10gu) s10b := float64(s10bu) @@ -619,12 +653,12 @@ func (z *ablScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image. s10g = xFrac1*s00g + xFrac0*s10g s10b = xFrac1*s00b + xFrac0*s10b s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sp.X+int(sx0), sp.Y+int(sy1)).RGBA() + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() s01r := float64(s01ru) s01g := float64(s01gu) s01b := float64(s01bu) s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sp.X+int(sx1), sp.Y+int(sy1)).RGBA() + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() s11r := float64(s11ru) s11g := float64(s11gu) s11b := float64(s11bu) @@ -646,9 +680,11 @@ func (z *ablScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image. } } -func (z *ablScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) { - yscale := float64(z.sh) / float64(z.dh) - xscale := float64(z.sw) / float64(z.dw) +func (ablInterpolator) scale_Image_Image(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) { + sw := int32(sr.Dx()) + sh := int32(sr.Dy()) + yscale := float64(sh) / float64(dr.Dy()) + xscale := float64(sw) / float64(dr.Dx()) dstColorRGBA64 := &color.RGBA64{} dstColor := color.Color(dstColorRGBA64) for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { @@ -660,7 +696,7 @@ func (z *ablScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Recta if sy < 0 { sy0, sy1 = 0, 0 yFrac0, yFrac1 = 0, 1 - } else if sy1 >= z.sh { + } else if sy1 >= sh { sy1 = sy0 yFrac0, yFrac1 = 1, 0 } @@ -673,16 +709,16 @@ func (z *ablScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Recta if sx < 0 { sx0, sx1 = 0, 0 xFrac0, xFrac1 = 0, 1 - } else if sx1 >= z.sw { + } else if sx1 >= sw { sx1 = sx0 xFrac0, xFrac1 = 1, 0 } - s00ru, s00gu, s00bu, s00au := src.At(sp.X+int(sx0), sp.Y+int(sy0)).RGBA() + s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() s00r := float64(s00ru) s00g := float64(s00gu) s00b := float64(s00bu) s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sp.X+int(sx1), sp.Y+int(sy0)).RGBA() + s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() s10r := float64(s10ru) s10g := float64(s10gu) s10b := float64(s10bu) @@ -691,12 +727,12 @@ func (z *ablScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Recta s10g = xFrac1*s00g + xFrac0*s10g s10b = xFrac1*s00b + xFrac0*s10b s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sp.X+int(sx0), sp.Y+int(sy1)).RGBA() + s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() s01r := float64(s01ru) s01g := float64(s01gu) s01b := float64(s01bu) s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sp.X+int(sx1), sp.Y+int(sy1)).RGBA() + s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() s11r := float64(s11ru) s11g := float64(s11gu) s11b := float64(s11bu) @@ -713,18 +749,19 @@ func (z *ablScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Recta dstColorRGBA64.G = uint16(s11g) dstColorRGBA64.B = uint16(s11b) dstColorRGBA64.A = uint16(s11a) - dst.Set(dp.X+int(dx), dp.Y+int(dy), dstColor) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) } } } -func (z *kernelScaler) Scale(dst Image, dp image.Point, src image.Image, sp image.Point) { - if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 { +func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle) { + if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) { + z.kernel.Scale(dst, dr, src, sr) return } - // adr is the affected destination pixels, relative to dp. - adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}}) - if adr.Empty() { + // adr is the affected destination pixels, relative to dr.Min. + adr := dst.Bounds().Intersect(dr).Sub(dr.Min) + if adr.Empty() || sr.Empty() { return } // Create a temporary buffer: @@ -736,40 +773,40 @@ func (z *kernelScaler) Scale(dst Image, dp image.Point, src image.Image, sp imag // sr is the source pixels. If it extends beyond the src bounds, // we cannot use the type-specific fast paths, as they access // the Pix fields directly without bounds checking. - if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) { - z.scaleX_Image(tmp, src, sp) + if !sr.In(src.Bounds()) { + z.scaleX_Image(tmp, src, sr) } else { switch src := src.(type) { case *image.Gray: - z.scaleX_Gray(tmp, src, sp) + z.scaleX_Gray(tmp, src, sr) case *image.NRGBA: - z.scaleX_NRGBA(tmp, src, sp) + z.scaleX_NRGBA(tmp, src, sr) case *image.RGBA: - z.scaleX_RGBA(tmp, src, sp) + z.scaleX_RGBA(tmp, src, sr) case *image.Uniform: - z.scaleX_Uniform(tmp, src, sp) + z.scaleX_Uniform(tmp, src, sr) case *image.YCbCr: - z.scaleX_YCbCr(tmp, src, sp) + z.scaleX_YCbCr(tmp, src, sr) default: - z.scaleX_Image(tmp, src, sp) + z.scaleX_Image(tmp, src, sr) } } switch dst := dst.(type) { case *image.RGBA: - z.scaleY_RGBA(dst, dp, adr, tmp) + z.scaleY_RGBA(dst, dr, adr, tmp) default: - z.scaleY_Image(dst, dp, adr, tmp) + z.scaleY_Image(dst, dr, adr, tmp) } } -func (z *kernelScaler) scaleX_Gray(tmp [][4]float64, src *image.Gray, sp image.Point) { +func (z *kernelScaler) scaleX_Gray(tmp [][4]float64, src *image.Gray, sr image.Rectangle) { t := 0 for y := int32(0); y < z.sh; y++ { for _, s := range z.horizontal.sources { var pr, pg, pb, pa float64 for _, c := range z.horizontal.contribs[s.i:s.j] { - pru, pgu, pbu, pau := src.At(sp.X+int(c.coord), sp.Y+int(y)).RGBA() + pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA() pr += float64(pru) * c.weight pg += float64(pgu) * c.weight pb += float64(pbu) * c.weight @@ -786,13 +823,13 @@ func (z *kernelScaler) scaleX_Gray(tmp [][4]float64, src *image.Gray, sp image.P } } -func (z *kernelScaler) scaleX_NRGBA(tmp [][4]float64, src *image.NRGBA, sp image.Point) { +func (z *kernelScaler) scaleX_NRGBA(tmp [][4]float64, src *image.NRGBA, sr image.Rectangle) { t := 0 for y := int32(0); y < z.sh; y++ { for _, s := range z.horizontal.sources { var pr, pg, pb, pa float64 for _, c := range z.horizontal.contribs[s.i:s.j] { - pru, pgu, pbu, pau := src.At(sp.X+int(c.coord), sp.Y+int(y)).RGBA() + pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA() pr += float64(pru) * c.weight pg += float64(pgu) * c.weight pb += float64(pbu) * c.weight @@ -809,13 +846,13 @@ func (z *kernelScaler) scaleX_NRGBA(tmp [][4]float64, src *image.NRGBA, sp image } } -func (z *kernelScaler) scaleX_RGBA(tmp [][4]float64, src *image.RGBA, sp image.Point) { +func (z *kernelScaler) scaleX_RGBA(tmp [][4]float64, src *image.RGBA, sr image.Rectangle) { t := 0 for y := int32(0); y < z.sh; y++ { for _, s := range z.horizontal.sources { var pr, pg, pb, pa float64 for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := src.PixOffset(sp.X+int(c.coord), sp.Y+int(y)) + pi := src.PixOffset(sr.Min.X+int(c.coord), sr.Min.Y+int(y)) pru := uint32(src.Pix[pi+0]) * 0x101 pgu := uint32(src.Pix[pi+1]) * 0x101 pbu := uint32(src.Pix[pi+2]) * 0x101 @@ -836,13 +873,13 @@ func (z *kernelScaler) scaleX_RGBA(tmp [][4]float64, src *image.RGBA, sp image.P } } -func (z *kernelScaler) scaleX_Uniform(tmp [][4]float64, src *image.Uniform, sp image.Point) { +func (z *kernelScaler) scaleX_Uniform(tmp [][4]float64, src *image.Uniform, sr image.Rectangle) { t := 0 for y := int32(0); y < z.sh; y++ { for _, s := range z.horizontal.sources { var pr, pg, pb, pa float64 for _, c := range z.horizontal.contribs[s.i:s.j] { - pru, pgu, pbu, pau := src.At(sp.X+int(c.coord), sp.Y+int(y)).RGBA() + pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA() pr += float64(pru) * c.weight pg += float64(pgu) * c.weight pb += float64(pbu) * c.weight @@ -859,13 +896,13 @@ func (z *kernelScaler) scaleX_Uniform(tmp [][4]float64, src *image.Uniform, sp i } } -func (z *kernelScaler) scaleX_YCbCr(tmp [][4]float64, src *image.YCbCr, sp image.Point) { +func (z *kernelScaler) scaleX_YCbCr(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle) { t := 0 for y := int32(0); y < z.sh; y++ { for _, s := range z.horizontal.sources { var pr, pg, pb, pa float64 for _, c := range z.horizontal.contribs[s.i:s.j] { - pru, pgu, pbu, pau := src.At(sp.X+int(c.coord), sp.Y+int(y)).RGBA() + pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA() pr += float64(pru) * c.weight pg += float64(pgu) * c.weight pb += float64(pbu) * c.weight @@ -882,13 +919,13 @@ func (z *kernelScaler) scaleX_YCbCr(tmp [][4]float64, src *image.YCbCr, sp image } } -func (z *kernelScaler) scaleX_Image(tmp [][4]float64, src image.Image, sp image.Point) { +func (z *kernelScaler) scaleX_Image(tmp [][4]float64, src image.Image, sr image.Rectangle) { t := 0 for y := int32(0); y < z.sh; y++ { for _, s := range z.horizontal.sources { var pr, pg, pb, pa float64 for _, c := range z.horizontal.contribs[s.i:s.j] { - pru, pgu, pbu, pau := src.At(sp.X+int(c.coord), sp.Y+int(y)).RGBA() + pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA() pr += float64(pru) * c.weight pg += float64(pgu) * c.weight pb += float64(pbu) * c.weight @@ -905,9 +942,9 @@ func (z *kernelScaler) scaleX_Image(tmp [][4]float64, src image.Image, sp image. } } -func (z *kernelScaler) scaleY_RGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, tmp [][4]float64) { +func (z *kernelScaler) scaleY_RGBA(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64) { for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - d := dst.PixOffset(dp.X+int(dx), dp.Y+adr.Min.Y) + d := dst.PixOffset(dr.Min.X+int(dx), dr.Min.Y+adr.Min.Y) for _, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { var pr, pg, pb, pa float64 for _, c := range z.vertical.contribs[s.i:s.j] { @@ -926,7 +963,7 @@ func (z *kernelScaler) scaleY_RGBA(dst *image.RGBA, dp image.Point, adr image.Re } } -func (z *kernelScaler) scaleY_Image(dst Image, dp image.Point, adr image.Rectangle, tmp [][4]float64) { +func (z *kernelScaler) scaleY_Image(dst Image, dr, adr image.Rectangle, tmp [][4]float64) { dstColorRGBA64 := &color.RGBA64{} dstColor := color.Color(dstColorRGBA64) for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { @@ -943,7 +980,7 @@ func (z *kernelScaler) scaleY_Image(dst Image, dp image.Point, adr image.Rectang dstColorRGBA64.G = ftou(pg * s.invTotalWeight) dstColorRGBA64.B = ftou(pb * s.invTotalWeight) dstColorRGBA64.A = ftou(pa * s.invTotalWeight) - dst.Set(dp.X+int(dx), dp.Y+int(adr.Min.Y+dy), dstColor) + dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor) } } } diff --git a/draw/scale.go b/draw/scale.go index 53ec801..9f8cdd4 100644 --- a/draw/scale.go +++ b/draw/scale.go @@ -6,16 +6,25 @@ package draw -// TODO: should Scale and NewScaler also take an Op argument? +// TODO: add an Options type a la +// https://groups.google.com/forum/#!topic/golang-dev/fgn_xM0aeq4 import ( "image" "math" ) -// Scale scales the part of the source image defined by src and sr and writes +// Scaler scales the part of the source image defined by src and sr and writes // to the part of the destination image defined by dst and dr. // +// A Scaler is safe to use concurrently. +type Scaler interface { + Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle) +} + +// Interpolator is an interpolation algorithm, when dst and src pixels don't +// have a 1:1 correspondance. +// // Of the interpolators provided by this package: // - NearestNeighbor is fast but usually looks worst. // - CatmullRom is slow but usually looks best. @@ -24,23 +33,9 @@ import ( // The time taken depends on the size of dr. For kernel interpolators, the // speed also depends on the size of sr, and so are often slower than // non-kernel interpolators, especially when scaling down. -func Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, q Interpolator) { - q.NewScaler(int32(dr.Dx()), int32(dr.Dy()), int32(sr.Dx()), int32(sr.Dy())).Scale(dst, dr.Min, src, sr.Min) -} - -// Scaler scales part of a source image, starting from sp, and writes to a -// destination image, starting from dp. The destination and source width and -// heights are pre-determined, as part of the Scaler. -// -// A Scaler is safe to use concurrently. -type Scaler interface { - Scale(dst Image, dp image.Point, src image.Image, sp image.Point) -} - -// Interpolator creates scalers for a given destination and source width and -// heights. type Interpolator interface { - NewScaler(dw, dh, sw, sh int32) Scaler + Scaler + // TODO: Transformer } // Kernel is an interpolator that blends source pixels weighted by a symmetric @@ -54,15 +49,22 @@ type Kernel struct { At func(t float64) float64 } -// NewScaler implements the Interpolator interface. -func (k *Kernel) NewScaler(dw, dh, sw, sh int32) Scaler { +// Scale implements the Scaler interface. +func (k *Kernel) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle) { + k.NewScaler(dr.Dx(), dr.Dy(), sr.Dx(), sr.Dy()).Scale(dst, dr, src, sr) +} + +// NewScaler returns a Scaler that is optimized for scaling multiple times with +// the same fixed destination and source width and height. +func (k *Kernel) NewScaler(dw, dh, sw, sh int) Scaler { return &kernelScaler{ - dw: dw, - dh: dh, - sw: sw, - sh: sh, - horizontal: newDistrib(k, dw, sw), - vertical: newDistrib(k, dh, sh), + kernel: k, + dw: int32(dw), + dh: int32(dh), + sw: int32(sw), + sh: int32(sh), + horizontal: newDistrib(k, int32(dw), int32(sw)), + vertical: newDistrib(k, int32(dh), int32(sh)), } } @@ -107,21 +109,10 @@ var ( type nnInterpolator struct{} -func (nnInterpolator) NewScaler(dw, dh, sw, sh int32) Scaler { return &nnScaler{dw, dh, sw, sh} } - -type nnScaler struct { - dw, dh, sw, sh int32 -} - type ablInterpolator struct{} -func (ablInterpolator) NewScaler(dw, dh, sw, sh int32) Scaler { return &ablScaler{dw, dh, sw, sh} } - -type ablScaler struct { - dw, dh, sw, sh int32 -} - type kernelScaler struct { + kernel *Kernel dw, dh, sw, sh int32 horizontal, vertical distrib } diff --git a/draw/scale_test.go b/draw/scale_test.go index c7c6ef2..8bc5a4b 100644 --- a/draw/scale_test.go +++ b/draw/scale_test.go @@ -47,7 +47,7 @@ func testScale(t *testing.T, w int, h int, direction, srcFilename string) { gotFilename := fmt.Sprintf("../testdata/go-turns-two-%s-%s.png", direction, name) got := image.NewRGBA(image.Rect(0, 0, w, h)) - Scale(got, got.Bounds(), src, src.Bounds(), q) + q.Scale(got, got.Bounds(), src, src.Bounds()) if *genScaleFiles { g, err := os.Create(gotFilename) if err != nil { @@ -112,12 +112,12 @@ func TestScaleClipCommute(t *testing.T) { } // Scale then clip. - Scale(dst0, outer, src, src.Bounds(), q) + q.Scale(dst0, outer, src, src.Bounds()) dst0 = dst0.SubImage(inner).(*image.RGBA) // Clip then scale. dst1 = dst1.SubImage(inner).(*image.RGBA) - Scale(dst1, outer, src, src.Bounds(), q) + q.Scale(dst1, outer, src, src.Bounds()) loop: for y := inner.Min.Y; y < inner.Max.Y; y++ { @@ -187,8 +187,8 @@ func TestFastPaths(t *testing.T) { dst1 := image.NewRGBA(drs[0]) Draw(dst0, dst0.Bounds(), blue, image.Point{}, Src) Draw(dstWrapper{dst1}, dst1.Bounds(), srcWrapper{blue}, image.Point{}, Src) - Scale(dst0, dr, src, sr, q) - Scale(dstWrapper{dst1}, dr, srcWrapper{src}, sr, q) + q.Scale(dst0, dr, src, sr) + q.Scale(dstWrapper{dst1}, dr, srcWrapper{src}, sr) if !bytes.Equal(dst0.Pix, dst1.Pix) { t.Errorf("pix differ for dr=%v, src=%T, sr=%v, q=%T", dr, src, sr, q) } @@ -260,11 +260,16 @@ func benchScale(b *testing.B, srcf func(image.Rectangle) (image.Image, error), w b.Fatal(err) } dr, sr := dst.Bounds(), src.Bounds() - scaler := q.NewScaler(int32(dr.Dx()), int32(dr.Dy()), int32(sr.Dx()), int32(sr.Dy())) + scaler := Scaler(q) + if n, ok := q.(interface { + NewScaler(int, int, int, int) Scaler + }); ok { + scaler = n.NewScaler(dr.Dx(), dr.Dy(), sr.Dx(), sr.Dy()) + } b.ResetTimer() for i := 0; i < b.N; i++ { - scaler.Scale(dst, dr.Min, src, sr.Min) + scaler.Scale(dst, dr, src, sr) } }