aw/golang-image
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
9b6f4595fb
golang-image/draw/impl.go

1819 lines
58 KiB
Go
Raw Normal View History

draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
// generated by "go run gen.go". DO NOT EDIT.
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
package draw
import (
"image"
"image/color"
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
"math"
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
"golang.org/x/image/math/f64"
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
)
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
func (z nnInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
// adr is the affected destination pixels, relative to dr.Min.
adr := dst.Bounds().Intersect(dr).Sub(dr.Min)
if adr.Empty() || sr.Empty() {
draw: clip scaling to the dst bounds. This is necessary for the upcoming RGBA dst fast path. The RGBA.Set slow path will clip automatically. Accessing RGBA.Pix directly will not. Benchmarks look like noise to me: benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6212108 6131166 -1.30% BenchmarkScaleLargeDownAB 15586042 15656681 +0.45% BenchmarkScaleLargeDownBL 1518783517 1508124217 -0.70% BenchmarkScaleLargeDownCR 2998969089 2978114154 -0.70% BenchmarkScaleDownNN 1821187 1809314 -0.65% BenchmarkScaleDownAB 4286983 4248974 -0.89% BenchmarkScaleDownBL 29396818 30181926 +2.67% BenchmarkScaleDownCR 56441945 57952417 +2.68% BenchmarkScaleUpNN 90325384 89734496 -0.65% BenchmarkScaleUpAB 211613922 211625435 +0.01% BenchmarkScaleUpBL 119730880 120817135 +0.91% BenchmarkScaleUpCR 178592665 182305702 +2.08% BenchmarkScaleSrcNRGBA 13271034 13210760 -0.45% BenchmarkScaleSrcRGBA 13082234 12997551 -0.65% BenchmarkScaleSrcUniform 4003966 3934184 -1.74% BenchmarkScaleSrcYCbCr 15939182 15900123 -0.25% Change-Id: Ibf2843bb3c4eb695b58030e7314053c669533016 Reviewed-on: https://go-review.googlesource.com/6073 Reviewed-by: Rob Pike <r@golang.org>
2015-02-26 06:20:04 +01:00
return
}
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
// 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.
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
if !sr.In(src.Bounds()) {
z.scale_Image_Image(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
} else {
switch dst := dst.(type) {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
case *image.RGBA:
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
switch src := src.(type) {
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
case *image.Gray:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_Gray(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.NRGBA:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_NRGBA(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.RGBA:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_RGBA(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.Uniform:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_Uniform(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.YCbCr:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_YCbCr(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
default:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_Image(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
default:
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
switch src := src.(type) {
default:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_Image_Image(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
func (z nnInterpolator) Transform(dst Image, s2d *f64.Aff3, src image.Image, sr image.Rectangle, opts *Options) {
dr := transformRect(s2d, &sr)
// adr is the affected destination pixels, relative to dr.Min.
adr := dst.Bounds().Intersect(dr).Sub(dr.Min)
if adr.Empty() || sr.Empty() {
return
}
d2s := invert(s2d)
draw: actually use type-specific Transform code paths. I simply forgot to do this in the previous change. Change-Id: I0ea5d6bb0a09154cb995a665476ffceb155bd49e Reviewed-on: https://go-review.googlesource.com/7651 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 00:57:00 +01:00
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.Gray:
z.transform_RGBA_Gray(dst, dr, adr, &d2s, src, sr)
case *image.NRGBA:
z.transform_RGBA_NRGBA(dst, dr, adr, &d2s, src, sr)
case *image.RGBA:
z.transform_RGBA_RGBA(dst, dr, adr, &d2s, src, sr)
case *image.Uniform:
z.transform_RGBA_Uniform(dst, dr, adr, &d2s, src, sr)
case *image.YCbCr:
z.transform_RGBA_YCbCr(dst, dr, adr, &d2s, src, sr)
default:
z.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr)
}
default:
switch src := src.(type) {
default:
z.transform_Image_Image(dst, dr, adr, &d2s, src, sr)
}
}
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
dst.Pix[d+0] = uint8(uint32(pr) >> 8)
dst.Pix[d+1] = uint8(uint32(pg) >> 8)
dst.Pix[d+2] = uint8(uint32(pb) >> 8)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(pr) >> 8)
dst.Pix[d+1] = uint8(uint32(pg) >> 8)
dst.Pix[d+2] = uint8(uint32(pb) >> 8)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
pi := src.PixOffset(sr.Min.X+int(sx), sr.Min.Y+int(sy))
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
pr := uint32(src.Pix[pi+0]) * 0x101
pg := uint32(src.Pix[pi+1]) * 0x101
pb := uint32(src.Pix[pi+2]) * 0x101
pa := uint32(src.Pix[pi+3]) * 0x101
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(pr) >> 8)
dst.Pix[d+1] = uint8(uint32(pg) >> 8)
dst.Pix[d+2] = uint8(uint32(pb) >> 8)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(pr) >> 8)
dst.Pix[d+1] = uint8(uint32(pg) >> 8)
dst.Pix[d+2] = uint8(uint32(pb) >> 8)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(pr) >> 8)
dst.Pix[d+1] = uint8(uint32(pg) >> 8)
dst.Pix[d+2] = uint8(uint32(pb) >> 8)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(pr) >> 8)
dst.Pix[d+1] = uint8(uint32(pg) >> 8)
dst.Pix[d+2] = uint8(uint32(pb) >> 8)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
dstColorRGBA64.R = uint16(pr)
dstColorRGBA64.G = uint16(pg)
dstColorRGBA64.B = uint16(pb)
dstColorRGBA64.A = uint16(pa)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
func (nnInterpolator) transform_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx0 := int(math.Floor(d2s[0]*dxf + d2s[1]*dyf + d2s[2]))
sy0 := int(math.Floor(d2s[3]*dxf + d2s[4]*dyf + d2s[5]))
if !(image.Point{sx0, sy0}).In(sr) {
continue
}
pr, pg, pb, pa := src.At(sx0, sy0).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)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
}
}
}
func (nnInterpolator) transform_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx0 := int(math.Floor(d2s[0]*dxf + d2s[1]*dyf + d2s[2]))
sy0 := int(math.Floor(d2s[3]*dxf + d2s[4]*dyf + d2s[5]))
if !(image.Point{sx0, sy0}).In(sr) {
continue
}
pr, pg, pb, pa := src.At(sx0, sy0).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)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
}
}
}
func (nnInterpolator) transform_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx0 := int(math.Floor(d2s[0]*dxf + d2s[1]*dyf + d2s[2]))
sy0 := int(math.Floor(d2s[3]*dxf + d2s[4]*dyf + d2s[5]))
if !(image.Point{sx0, sy0}).In(sr) {
continue
}
pi := src.PixOffset(sx0, sy0)
pr := uint32(src.Pix[pi+0]) * 0x101
pg := uint32(src.Pix[pi+1]) * 0x101
pb := uint32(src.Pix[pi+2]) * 0x101
pa := uint32(src.Pix[pi+3]) * 0x101
dst.Pix[d+0] = uint8(uint32(pr) >> 8)
dst.Pix[d+1] = uint8(uint32(pg) >> 8)
dst.Pix[d+2] = uint8(uint32(pb) >> 8)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
}
}
}
func (nnInterpolator) transform_RGBA_Uniform(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Uniform, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx0 := int(math.Floor(d2s[0]*dxf + d2s[1]*dyf + d2s[2]))
sy0 := int(math.Floor(d2s[3]*dxf + d2s[4]*dyf + d2s[5]))
if !(image.Point{sx0, sy0}).In(sr) {
continue
}
pr, pg, pb, pa := src.At(sx0, sy0).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)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
}
}
}
func (nnInterpolator) transform_RGBA_YCbCr(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx0 := int(math.Floor(d2s[0]*dxf + d2s[1]*dyf + d2s[2]))
sy0 := int(math.Floor(d2s[3]*dxf + d2s[4]*dyf + d2s[5]))
if !(image.Point{sx0, sy0}).In(sr) {
continue
}
pr, pg, pb, pa := src.At(sx0, sy0).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)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
}
}
}
func (nnInterpolator) transform_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx0 := int(math.Floor(d2s[0]*dxf + d2s[1]*dyf + d2s[2]))
sy0 := int(math.Floor(d2s[3]*dxf + d2s[4]*dyf + d2s[5]))
if !(image.Point{sx0, sy0}).In(sr) {
continue
}
pr, pg, pb, pa := src.At(sx0, sy0).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)
dst.Pix[d+3] = uint8(uint32(pa) >> 8)
}
}
}
func (nnInterpolator) transform_Image_Image(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle) {
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx0 := int(math.Floor(d2s[0]*dxf + d2s[1]*dyf + d2s[2]))
sy0 := int(math.Floor(d2s[3]*dxf + d2s[4]*dyf + d2s[5]))
if !(image.Point{sx0, sy0}).In(sr) {
continue
}
pr, pg, pb, pa := src.At(sx0, sy0).RGBA()
dstColorRGBA64.R = uint16(pr)
dstColorRGBA64.G = uint16(pg)
dstColorRGBA64.B = uint16(pb)
dstColorRGBA64.A = uint16(pa)
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
}
}
}
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
func (z ablInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
// adr is the affected destination pixels, relative to dr.Min.
adr := dst.Bounds().Intersect(dr).Sub(dr.Min)
if adr.Empty() || sr.Empty() {
draw: clip scaling to the dst bounds. This is necessary for the upcoming RGBA dst fast path. The RGBA.Set slow path will clip automatically. Accessing RGBA.Pix directly will not. Benchmarks look like noise to me: benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6212108 6131166 -1.30% BenchmarkScaleLargeDownAB 15586042 15656681 +0.45% BenchmarkScaleLargeDownBL 1518783517 1508124217 -0.70% BenchmarkScaleLargeDownCR 2998969089 2978114154 -0.70% BenchmarkScaleDownNN 1821187 1809314 -0.65% BenchmarkScaleDownAB 4286983 4248974 -0.89% BenchmarkScaleDownBL 29396818 30181926 +2.67% BenchmarkScaleDownCR 56441945 57952417 +2.68% BenchmarkScaleUpNN 90325384 89734496 -0.65% BenchmarkScaleUpAB 211613922 211625435 +0.01% BenchmarkScaleUpBL 119730880 120817135 +0.91% BenchmarkScaleUpCR 178592665 182305702 +2.08% BenchmarkScaleSrcNRGBA 13271034 13210760 -0.45% BenchmarkScaleSrcRGBA 13082234 12997551 -0.65% BenchmarkScaleSrcUniform 4003966 3934184 -1.74% BenchmarkScaleSrcYCbCr 15939182 15900123 -0.25% Change-Id: Ibf2843bb3c4eb695b58030e7314053c669533016 Reviewed-on: https://go-review.googlesource.com/6073 Reviewed-by: Rob Pike <r@golang.org>
2015-02-26 06:20:04 +01:00
return
}
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
// 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.
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
if !sr.In(src.Bounds()) {
z.scale_Image_Image(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
} else {
switch dst := dst.(type) {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
case *image.RGBA:
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
switch src := src.(type) {
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
case *image.Gray:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_Gray(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.NRGBA:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_NRGBA(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.RGBA:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_RGBA(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.Uniform:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_Uniform(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.YCbCr:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_YCbCr(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
default:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_RGBA_Image(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
default:
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
switch src := src.(type) {
default:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scale_Image_Image(dst, dr, adr, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
func (z ablInterpolator) Transform(dst Image, s2d *f64.Aff3, src image.Image, sr image.Rectangle, opts *Options) {
dr := transformRect(s2d, &sr)
// adr is the affected destination pixels, relative to dr.Min.
adr := dst.Bounds().Intersect(dr).Sub(dr.Min)
if adr.Empty() || sr.Empty() {
return
}
d2s := invert(s2d)
draw: actually use type-specific Transform code paths. I simply forgot to do this in the previous change. Change-Id: I0ea5d6bb0a09154cb995a665476ffceb155bd49e Reviewed-on: https://go-review.googlesource.com/7651 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 00:57:00 +01:00
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.Gray:
z.transform_RGBA_Gray(dst, dr, adr, &d2s, src, sr)
case *image.NRGBA:
z.transform_RGBA_NRGBA(dst, dr, adr, &d2s, src, sr)
case *image.RGBA:
z.transform_RGBA_RGBA(dst, dr, adr, &d2s, src, sr)
case *image.Uniform:
z.transform_RGBA_Uniform(dst, dr, adr, &d2s, src, sr)
case *image.YCbCr:
z.transform_RGBA_YCbCr(dst, dr, adr, &d2s, src, sr)
default:
z.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr)
}
default:
switch src := src.(type) {
default:
z.transform_Image_Image(dst, dr, adr, &d2s, src, sr)
}
}
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
swMinus1, shMinus1 := sw-1, sh-1
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
sy := (float64(dy)+0.5)*yscale - 0.5
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
// If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if
// we say int32(sy) instead of int32(math.Floor(sy)). Similarly for
// sx, below.
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
sy0 := int32(sy)
yFrac0 := sy - float64(sy0)
yFrac1 := 1 - yFrac0
sy1 := sy0 + 1
if sy < 0 {
sy0, sy1 = 0, 0
yFrac0, yFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sy1 > shMinus1 {
sy0, sy1 = shMinus1, shMinus1
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
yFrac0, yFrac1 = 1, 0
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
sx := (float64(dx)+0.5)*xscale - 0.5
sx0 := int32(sx)
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
if sx < 0 {
sx0, sx1 = 0, 0
xFrac0, xFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
swMinus1, shMinus1 := sw-1, sh-1
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy := (float64(dy)+0.5)*yscale - 0.5
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
// If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if
// we say int32(sy) instead of int32(math.Floor(sy)). Similarly for
// sx, below.
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy0 := int32(sy)
yFrac0 := sy - float64(sy0)
yFrac1 := 1 - yFrac0
sy1 := sy0 + 1
if sy < 0 {
sy0, sy1 = 0, 0
yFrac0, yFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sy1 > shMinus1 {
sy0, sy1 = shMinus1, shMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
yFrac0, yFrac1 = 1, 0
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sx := (float64(dx)+0.5)*xscale - 0.5
sx0 := int32(sx)
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
if sx < 0 {
sx0, sx1 = 0, 0
xFrac0, xFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
swMinus1, shMinus1 := sw-1, sh-1
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy := (float64(dy)+0.5)*yscale - 0.5
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
// If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if
// we say int32(sy) instead of int32(math.Floor(sy)). Similarly for
// sx, below.
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy0 := int32(sy)
yFrac0 := sy - float64(sy0)
yFrac1 := 1 - yFrac0
sy1 := sy0 + 1
if sy < 0 {
sy0, sy1 = 0, 0
yFrac0, yFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sy1 > shMinus1 {
sy0, sy1 = shMinus1, shMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
yFrac0, yFrac1 = 1, 0
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sx := (float64(dx)+0.5)*xscale - 0.5
sx0 := int32(sx)
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
if sx < 0 {
sx0, sx1 = 0, 0
xFrac0, xFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s00i := src.PixOffset(sr.Min.X+int(sx0), sr.Min.Y+int(sy0))
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
s00ru := uint32(src.Pix[s00i+0]) * 0x101
s00gu := uint32(src.Pix[s00i+1]) * 0x101
s00bu := uint32(src.Pix[s00i+2]) * 0x101
s00au := uint32(src.Pix[s00i+3]) * 0x101
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s10i := src.PixOffset(sr.Min.X+int(sx1), sr.Min.Y+int(sy0))
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
s10ru := uint32(src.Pix[s10i+0]) * 0x101
s10gu := uint32(src.Pix[s10i+1]) * 0x101
s10bu := uint32(src.Pix[s10i+2]) * 0x101
s10au := uint32(src.Pix[s10i+3]) * 0x101
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s01i := src.PixOffset(sr.Min.X+int(sx0), sr.Min.Y+int(sy1))
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
s01ru := uint32(src.Pix[s01i+0]) * 0x101
s01gu := uint32(src.Pix[s01i+1]) * 0x101
s01bu := uint32(src.Pix[s01i+2]) * 0x101
s01au := uint32(src.Pix[s01i+3]) * 0x101
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s11i := src.PixOffset(sr.Min.X+int(sx1), sr.Min.Y+int(sy1))
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
s11ru := uint32(src.Pix[s11i+0]) * 0x101
s11gu := uint32(src.Pix[s11i+1]) * 0x101
s11bu := uint32(src.Pix[s11i+2]) * 0x101
s11au := uint32(src.Pix[s11i+3]) * 0x101
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
swMinus1, shMinus1 := sw-1, sh-1
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy := (float64(dy)+0.5)*yscale - 0.5
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
// If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if
// we say int32(sy) instead of int32(math.Floor(sy)). Similarly for
// sx, below.
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy0 := int32(sy)
yFrac0 := sy - float64(sy0)
yFrac1 := 1 - yFrac0
sy1 := sy0 + 1
if sy < 0 {
sy0, sy1 = 0, 0
yFrac0, yFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sy1 > shMinus1 {
sy0, sy1 = shMinus1, shMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
yFrac0, yFrac1 = 1, 0
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sx := (float64(dx)+0.5)*xscale - 0.5
sx0 := int32(sx)
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
if sx < 0 {
sx0, sx1 = 0, 0
xFrac0, xFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
swMinus1, shMinus1 := sw-1, sh-1
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy := (float64(dy)+0.5)*yscale - 0.5
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
// If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if
// we say int32(sy) instead of int32(math.Floor(sy)). Similarly for
// sx, below.
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy0 := int32(sy)
yFrac0 := sy - float64(sy0)
yFrac1 := 1 - yFrac0
sy1 := sy0 + 1
if sy < 0 {
sy0, sy1 = 0, 0
yFrac0, yFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sy1 > shMinus1 {
sy0, sy1 = shMinus1, shMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
yFrac0, yFrac1 = 1, 0
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sx := (float64(dx)+0.5)*xscale - 0.5
sx0 := int32(sx)
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
if sx < 0 {
sx0, sx1 = 0, 0
xFrac0, xFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
swMinus1, shMinus1 := sw-1, sh-1
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy := (float64(dy)+0.5)*yscale - 0.5
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
// If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if
// we say int32(sy) instead of int32(math.Floor(sy)). Similarly for
// sx, below.
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sy0 := int32(sy)
yFrac0 := sy - float64(sy0)
yFrac1 := 1 - yFrac0
sy1 := sy0 + 1
if sy < 0 {
sy0, sy1 = 0, 0
yFrac0, yFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sy1 > shMinus1 {
sy0, sy1 = shMinus1, shMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
yFrac0, yFrac1 = 1, 0
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
sx := (float64(dx)+0.5)*xscale - 0.5
sx0 := int32(sx)
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
if sx < 0 {
sx0, sx1 = 0, 0
xFrac0, xFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
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())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
swMinus1, shMinus1 := sw-1, sh-1
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
sy := (float64(dy)+0.5)*yscale - 0.5
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
// If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if
// we say int32(sy) instead of int32(math.Floor(sy)). Similarly for
// sx, below.
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
sy0 := int32(sy)
yFrac0 := sy - float64(sy0)
yFrac1 := 1 - yFrac0
sy1 := sy0 + 1
if sy < 0 {
sy0, sy1 = 0, 0
yFrac0, yFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sy1 > shMinus1 {
sy0, sy1 = shMinus1, shMinus1
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
yFrac0, yFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
sx := (float64(dx)+0.5)*xscale - 0.5
sx0 := int32(sx)
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
if sx < 0 {
sx0, sx1 = 0, 0
xFrac0, xFrac1 = 0, 1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dstColorRGBA64.R = uint16(s11r)
dstColorRGBA64.G = uint16(s11g)
dstColorRGBA64.B = uint16(s11b)
dstColorRGBA64.A = uint16(s11a)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
}
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
func (ablInterpolator) transform_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2]
sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5]
if !(image.Point{int(math.Floor(sx)), int(math.Floor(sy))}).In(sr) {
continue
}
sx -= 0.5
sxf := math.Floor(sx)
xFrac0 := sx - sxf
xFrac1 := 1 - xFrac0
sx0 := int(sxf)
sx1 := sx0 + 1
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
xFrac0, xFrac1 = 0, 1
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
xFrac0, xFrac1 = 1, 0
}
sy -= 0.5
syf := math.Floor(sy)
yFrac0 := sy - syf
yFrac1 := 1 - yFrac0
sy0 := int(syf)
sy1 := sy0 + 1
if sy0 < sr.Min.Y {
sy0, sy1 = sr.Min.Y, sr.Min.Y
yFrac0, yFrac1 = 0, 1
} else if sy1 >= sr.Max.Y {
sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1
yFrac0, yFrac1 = 1, 0
}
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
}
}
}
func (ablInterpolator) transform_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2]
sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5]
if !(image.Point{int(math.Floor(sx)), int(math.Floor(sy))}).In(sr) {
continue
}
sx -= 0.5
sxf := math.Floor(sx)
xFrac0 := sx - sxf
xFrac1 := 1 - xFrac0
sx0 := int(sxf)
sx1 := sx0 + 1
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
xFrac0, xFrac1 = 0, 1
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
xFrac0, xFrac1 = 1, 0
}
sy -= 0.5
syf := math.Floor(sy)
yFrac0 := sy - syf
yFrac1 := 1 - yFrac0
sy0 := int(syf)
sy1 := sy0 + 1
if sy0 < sr.Min.Y {
sy0, sy1 = sr.Min.Y, sr.Min.Y
yFrac0, yFrac1 = 0, 1
} else if sy1 >= sr.Max.Y {
sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1
yFrac0, yFrac1 = 1, 0
}
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
}
}
}
func (ablInterpolator) transform_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2]
sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5]
if !(image.Point{int(math.Floor(sx)), int(math.Floor(sy))}).In(sr) {
continue
}
sx -= 0.5
sxf := math.Floor(sx)
xFrac0 := sx - sxf
xFrac1 := 1 - xFrac0
sx0 := int(sxf)
sx1 := sx0 + 1
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
xFrac0, xFrac1 = 0, 1
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
xFrac0, xFrac1 = 1, 0
}
sy -= 0.5
syf := math.Floor(sy)
yFrac0 := sy - syf
yFrac1 := 1 - yFrac0
sy0 := int(syf)
sy1 := sy0 + 1
if sy0 < sr.Min.Y {
sy0, sy1 = sr.Min.Y, sr.Min.Y
yFrac0, yFrac1 = 0, 1
} else if sy1 >= sr.Max.Y {
sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1
yFrac0, yFrac1 = 1, 0
}
s00i := src.PixOffset(sx0, sy0)
s00ru := uint32(src.Pix[s00i+0]) * 0x101
s00gu := uint32(src.Pix[s00i+1]) * 0x101
s00bu := uint32(src.Pix[s00i+2]) * 0x101
s00au := uint32(src.Pix[s00i+3]) * 0x101
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
s10i := src.PixOffset(sx1, sy0)
s10ru := uint32(src.Pix[s10i+0]) * 0x101
s10gu := uint32(src.Pix[s10i+1]) * 0x101
s10bu := uint32(src.Pix[s10i+2]) * 0x101
s10au := uint32(src.Pix[s10i+3]) * 0x101
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
s01i := src.PixOffset(sx0, sy1)
s01ru := uint32(src.Pix[s01i+0]) * 0x101
s01gu := uint32(src.Pix[s01i+1]) * 0x101
s01bu := uint32(src.Pix[s01i+2]) * 0x101
s01au := uint32(src.Pix[s01i+3]) * 0x101
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
s11i := src.PixOffset(sx1, sy1)
s11ru := uint32(src.Pix[s11i+0]) * 0x101
s11gu := uint32(src.Pix[s11i+1]) * 0x101
s11bu := uint32(src.Pix[s11i+2]) * 0x101
s11au := uint32(src.Pix[s11i+3]) * 0x101
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
}
}
}
func (ablInterpolator) transform_RGBA_Uniform(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Uniform, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2]
sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5]
if !(image.Point{int(math.Floor(sx)), int(math.Floor(sy))}).In(sr) {
continue
}
sx -= 0.5
sxf := math.Floor(sx)
xFrac0 := sx - sxf
xFrac1 := 1 - xFrac0
sx0 := int(sxf)
sx1 := sx0 + 1
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
xFrac0, xFrac1 = 0, 1
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
xFrac0, xFrac1 = 1, 0
}
sy -= 0.5
syf := math.Floor(sy)
yFrac0 := sy - syf
yFrac1 := 1 - yFrac0
sy0 := int(syf)
sy1 := sy0 + 1
if sy0 < sr.Min.Y {
sy0, sy1 = sr.Min.Y, sr.Min.Y
yFrac0, yFrac1 = 0, 1
} else if sy1 >= sr.Max.Y {
sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1
yFrac0, yFrac1 = 1, 0
}
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
}
}
}
func (ablInterpolator) transform_RGBA_YCbCr(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2]
sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5]
if !(image.Point{int(math.Floor(sx)), int(math.Floor(sy))}).In(sr) {
continue
}
sx -= 0.5
sxf := math.Floor(sx)
xFrac0 := sx - sxf
xFrac1 := 1 - xFrac0
sx0 := int(sxf)
sx1 := sx0 + 1
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
xFrac0, xFrac1 = 0, 1
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
xFrac0, xFrac1 = 1, 0
}
sy -= 0.5
syf := math.Floor(sy)
yFrac0 := sy - syf
yFrac1 := 1 - yFrac0
sy0 := int(syf)
sy1 := sy0 + 1
if sy0 < sr.Min.Y {
sy0, sy1 = sr.Min.Y, sr.Min.Y
yFrac0, yFrac1 = 0, 1
} else if sy1 >= sr.Max.Y {
sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1
yFrac0, yFrac1 = 1, 0
}
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
}
}
}
func (ablInterpolator) transform_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle) {
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
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, d = dx+1, d+4 {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2]
sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5]
if !(image.Point{int(math.Floor(sx)), int(math.Floor(sy))}).In(sr) {
continue
}
sx -= 0.5
sxf := math.Floor(sx)
xFrac0 := sx - sxf
xFrac1 := 1 - xFrac0
sx0 := int(sxf)
sx1 := sx0 + 1
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
xFrac0, xFrac1 = 0, 1
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
xFrac0, xFrac1 = 1, 0
}
sy -= 0.5
syf := math.Floor(sy)
yFrac0 := sy - syf
yFrac1 := 1 - yFrac0
sy0 := int(syf)
sy1 := sy0 + 1
if sy0 < sr.Min.Y {
sy0, sy1 = sr.Min.Y, sr.Min.Y
yFrac0, yFrac1 = 0, 1
} else if sy1 >= sr.Max.Y {
sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1
yFrac0, yFrac1 = 1, 0
}
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dst.Pix[d+0] = uint8(uint32(s11r) >> 8)
dst.Pix[d+1] = uint8(uint32(s11g) >> 8)
dst.Pix[d+2] = uint8(uint32(s11b) >> 8)
dst.Pix[d+3] = uint8(uint32(s11a) >> 8)
}
}
}
func (ablInterpolator) transform_Image_Image(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle) {
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
dxf := float64(dr.Min.X+int(dx)) + 0.5
sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2]
sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5]
if !(image.Point{int(math.Floor(sx)), int(math.Floor(sy))}).In(sr) {
continue
}
sx -= 0.5
sxf := math.Floor(sx)
xFrac0 := sx - sxf
xFrac1 := 1 - xFrac0
sx0 := int(sxf)
sx1 := sx0 + 1
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
xFrac0, xFrac1 = 0, 1
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
xFrac0, xFrac1 = 1, 0
}
sy -= 0.5
syf := math.Floor(sy)
yFrac0 := sy - syf
yFrac1 := 1 - yFrac0
sy0 := int(syf)
sy1 := sy0 + 1
if sy0 < sr.Min.Y {
sy0, sy1 = sr.Min.Y, sr.Min.Y
yFrac0, yFrac1 = 0, 1
} else if sy1 >= sr.Max.Y {
sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1
yFrac0, yFrac1 = 1, 0
}
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
dstColorRGBA64.R = uint16(s11r)
dstColorRGBA64.G = uint16(s11g)
dstColorRGBA64.B = uint16(s11b)
dstColorRGBA64.A = uint16(s11a)
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
}
}
}
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) {
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
z.kernel.Scale(dst, dr, src, sr, opts)
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
return
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
// adr is the affected destination pixels, relative to dr.Min.
adr := dst.Bounds().Intersect(dr).Sub(dr.Min)
if adr.Empty() || sr.Empty() {
draw: clip scaling to the dst bounds. This is necessary for the upcoming RGBA dst fast path. The RGBA.Set slow path will clip automatically. Accessing RGBA.Pix directly will not. Benchmarks look like noise to me: benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6212108 6131166 -1.30% BenchmarkScaleLargeDownAB 15586042 15656681 +0.45% BenchmarkScaleLargeDownBL 1518783517 1508124217 -0.70% BenchmarkScaleLargeDownCR 2998969089 2978114154 -0.70% BenchmarkScaleDownNN 1821187 1809314 -0.65% BenchmarkScaleDownAB 4286983 4248974 -0.89% BenchmarkScaleDownBL 29396818 30181926 +2.67% BenchmarkScaleDownCR 56441945 57952417 +2.68% BenchmarkScaleUpNN 90325384 89734496 -0.65% BenchmarkScaleUpAB 211613922 211625435 +0.01% BenchmarkScaleUpBL 119730880 120817135 +0.91% BenchmarkScaleUpCR 178592665 182305702 +2.08% BenchmarkScaleSrcNRGBA 13271034 13210760 -0.45% BenchmarkScaleSrcRGBA 13082234 12997551 -0.65% BenchmarkScaleSrcUniform 4003966 3934184 -1.74% BenchmarkScaleSrcYCbCr 15939182 15900123 -0.25% Change-Id: Ibf2843bb3c4eb695b58030e7314053c669533016 Reviewed-on: https://go-review.googlesource.com/6073 Reviewed-by: Rob Pike <r@golang.org>
2015-02-26 06:20:04 +01:00
return
}
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
// Create a temporary buffer:
// scaleX distributes the source image's columns over the temporary image.
// scaleY distributes the temporary image's rows over the destination image.
// TODO: is it worth having a sync.Pool for this temporary buffer?
tmp := make([][4]float64, z.dw*z.sh)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
// 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.
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
if !sr.In(src.Bounds()) {
z.scaleX_Image(tmp, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
} else {
switch src := src.(type) {
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
case *image.Gray:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleX_Gray(tmp, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.NRGBA:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleX_NRGBA(tmp, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.RGBA:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleX_RGBA(tmp, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.Uniform:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleX_Uniform(tmp, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.YCbCr:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleX_YCbCr(tmp, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
default:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleX_Image(tmp, src, sr)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
switch dst := dst.(type) {
case *image.RGBA:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleY_RGBA(dst, dr, adr, tmp)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
default:
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
z.scaleY_Image(dst, dr, adr, tmp)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
func (z *Kernel) Transform(dst Image, m *f64.Aff3, src image.Image, sr image.Rectangle, opts *Options) {
panic("unimplemented")
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleX_Gray(tmp [][4]float64, src *image.Gray, sr image.Rectangle) {
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
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] {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA()
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
pa += float64(pau) * c.weight
}
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
}
t++
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleX_NRGBA(tmp [][4]float64, src *image.NRGBA, sr image.Rectangle) {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
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] {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
pa += float64(pau) * c.weight
}
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
}
t++
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleX_RGBA(tmp [][4]float64, src *image.RGBA, sr image.Rectangle) {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
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] {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
pi := src.PixOffset(sr.Min.X+int(c.coord), sr.Min.Y+int(y))
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
pru := uint32(src.Pix[pi+0]) * 0x101
pgu := uint32(src.Pix[pi+1]) * 0x101
pbu := uint32(src.Pix[pi+2]) * 0x101
pau := uint32(src.Pix[pi+3]) * 0x101
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
pa += float64(pau) * c.weight
}
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
}
t++
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleX_Uniform(tmp [][4]float64, src *image.Uniform, sr image.Rectangle) {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
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] {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
pa += float64(pau) * c.weight
}
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
}
t++
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleX_YCbCr(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle) {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
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] {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA()
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
pa += float64(pau) * c.weight
}
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
}
t++
}
}
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleX_Image(tmp [][4]float64, src image.Image, sr image.Rectangle) {
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
t := 0
for y := int32(0); y < z.sh; y++ {
for _, s := range z.horizontal.sources {
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
var pr, pg, pb, pa float64
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
for _, c := range z.horizontal.contribs[s.i:s.j] {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA()
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
pa += float64(pau) * c.weight
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
tmp[t] = [4]float64{
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
t++
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleY_RGBA(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64) {
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
d := dst.PixOffset(dr.Min.X+int(dx), dr.Min.Y+adr.Min.Y)
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for _, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] {
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
var pr, pg, pb, pa float64
for _, c := range z.vertical.contribs[s.i:s.j] {
draw: clip scaling to the dst bounds. This is necessary for the upcoming RGBA dst fast path. The RGBA.Set slow path will clip automatically. Accessing RGBA.Pix directly will not. Benchmarks look like noise to me: benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6212108 6131166 -1.30% BenchmarkScaleLargeDownAB 15586042 15656681 +0.45% BenchmarkScaleLargeDownBL 1518783517 1508124217 -0.70% BenchmarkScaleLargeDownCR 2998969089 2978114154 -0.70% BenchmarkScaleDownNN 1821187 1809314 -0.65% BenchmarkScaleDownAB 4286983 4248974 -0.89% BenchmarkScaleDownBL 29396818 30181926 +2.67% BenchmarkScaleDownCR 56441945 57952417 +2.68% BenchmarkScaleUpNN 90325384 89734496 -0.65% BenchmarkScaleUpAB 211613922 211625435 +0.01% BenchmarkScaleUpBL 119730880 120817135 +0.91% BenchmarkScaleUpCR 178592665 182305702 +2.08% BenchmarkScaleSrcNRGBA 13271034 13210760 -0.45% BenchmarkScaleSrcRGBA 13082234 12997551 -0.65% BenchmarkScaleSrcUniform 4003966 3934184 -1.74% BenchmarkScaleSrcYCbCr 15939182 15900123 -0.25% Change-Id: Ibf2843bb3c4eb695b58030e7314053c669533016 Reviewed-on: https://go-review.googlesource.com/6073 Reviewed-by: Rob Pike <r@golang.org>
2015-02-26 06:20:04 +01:00
p := &tmp[c.coord*z.dw+dx]
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
pr += p[0] * c.weight
pg += p[1] * c.weight
pb += p[2] * c.weight
pa += p[3] * c.weight
}
draw: RGBA dst fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6124873 3348203 -45.33% BenchmarkScaleLargeDownAB 15608417 12626534 -19.10% BenchmarkScaleLargeDownBL 1503354937 1482605150 -1.38% BenchmarkScaleLargeDownCR 2987623786 2937846270 -1.67% BenchmarkScaleDownNN 1793478 935896 -47.82% BenchmarkScaleDownAB 4277596 3405613 -20.38% BenchmarkScaleDownBL 29932226 29268085 -2.22% BenchmarkScaleDownCR 57563042 57322266 -0.42% BenchmarkScaleUpNN 89694138 46216098 -48.47% BenchmarkScaleUpAB 212318283 169267373 -20.28% BenchmarkScaleUpBL 120899444 80215032 -33.65% BenchmarkScaleUpCR 181116518 140140247 -22.62% BenchmarkScaleSrcNRGBA 13229017 10620746 -19.72% BenchmarkScaleSrcRGBA 12993292 10155919 -21.84% BenchmarkScaleSrcUniform 3964808 1146947 -71.07% BenchmarkScaleSrcYCbCr 15871184 12779895 -19.48% Change-Id: I7d92bd9f4c20692c5a52ea31019fe3852e657535 Reviewed-on: https://go-review.googlesource.com/6230 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 06:18:34 +01:00
dst.Pix[d+0] = uint8(ftou(pr*s.invTotalWeight) >> 8)
dst.Pix[d+1] = uint8(ftou(pg*s.invTotalWeight) >> 8)
dst.Pix[d+2] = uint8(ftou(pb*s.invTotalWeight) >> 8)
dst.Pix[d+3] = uint8(ftou(pa*s.invTotalWeight) >> 8)
d += dst.Stride
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
func (z *kernelScaler) scaleY_Image(dst Image, dr, adr image.Rectangle, tmp [][4]float64) {
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] {
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
var pr, pg, pb, pa float64
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
for _, c := range z.vertical.contribs[s.i:s.j] {
draw: clip scaling to the dst bounds. This is necessary for the upcoming RGBA dst fast path. The RGBA.Set slow path will clip automatically. Accessing RGBA.Pix directly will not. Benchmarks look like noise to me: benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6212108 6131166 -1.30% BenchmarkScaleLargeDownAB 15586042 15656681 +0.45% BenchmarkScaleLargeDownBL 1518783517 1508124217 -0.70% BenchmarkScaleLargeDownCR 2998969089 2978114154 -0.70% BenchmarkScaleDownNN 1821187 1809314 -0.65% BenchmarkScaleDownAB 4286983 4248974 -0.89% BenchmarkScaleDownBL 29396818 30181926 +2.67% BenchmarkScaleDownCR 56441945 57952417 +2.68% BenchmarkScaleUpNN 90325384 89734496 -0.65% BenchmarkScaleUpAB 211613922 211625435 +0.01% BenchmarkScaleUpBL 119730880 120817135 +0.91% BenchmarkScaleUpCR 178592665 182305702 +2.08% BenchmarkScaleSrcNRGBA 13271034 13210760 -0.45% BenchmarkScaleSrcRGBA 13082234 12997551 -0.65% BenchmarkScaleSrcUniform 4003966 3934184 -1.74% BenchmarkScaleSrcYCbCr 15939182 15900123 -0.25% Change-Id: Ibf2843bb3c4eb695b58030e7314053c669533016 Reviewed-on: https://go-review.googlesource.com/6073 Reviewed-by: Rob Pike <r@golang.org>
2015-02-26 06:20:04 +01:00
p := &tmp[c.coord*z.dw+dx]
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
pr += p[0] * c.weight
pg += p[1] * c.weight
pb += p[2] * c.weight
pa += p[3] * c.weight
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
dstColorRGBA64.R = ftou(pr * s.invTotalWeight)
dstColorRGBA64.G = ftou(pg * s.invTotalWeight)
dstColorRGBA64.B = ftou(pb * s.invTotalWeight)
dstColorRGBA64.A = ftou(pa * s.invTotalWeight)
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 <r@golang.org>
2015-03-03 06:54:53 +01:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor)
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
}
}
Reference in New Issue Copy Permalink