draw: implement NearestNeighbor and ApproxBiLinear Transform.
Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
This commit is contained in:
Nigel Tao
parent
ab1ce1a88c
commit
87013da148
|
|
@ -9,7 +9,6 @@ import (
|
|||
"image"
|
||||
"image/png"
|
||||
"log"
|
||||
"math"
|
||||
"os"
|
||||
|
||||
"golang.org/x/image/draw"
|
||||
|
|
@ -34,19 +33,17 @@ func ExampleDraw() {
|
|||
draw.ApproxBiLinear,
|
||||
draw.CatmullRom,
|
||||
}
|
||||
c, s := math.Cos(math.Pi/3), math.Sin(math.Pi/3)
|
||||
const cos60, sin60 = 0.5, 0.866025404
|
||||
t := &f64.Aff3{
|
||||
+2 * c, -2 * s, 100,
|
||||
+2 * s, +2 * c, 100,
|
||||
+2 * cos60, -2 * sin60, 100,
|
||||
+2 * sin60, +2 * cos60, 100,
|
||||
}
|
||||
|
||||
draw.Copy(dst, image.Point{20, 30}, src, sr, nil)
|
||||
for i, q := range qs {
|
||||
q.Scale(dst, image.Rect(200+10*i, 100*i, 600+10*i, 150+100*i), src, sr, nil)
|
||||
}
|
||||
// TODO: delete the "_ = t" and uncomment this when Transform is implemented.
|
||||
// draw.NearestNeighbor.Transform(dst, t, src, sr, nil)
|
||||
_ = t
|
||||
draw.NearestNeighbor.Transform(dst, t, src, sr, nil)
|
||||
|
||||
// Change false to true to write the resultant image to disk.
|
||||
if false {
|
||||
|
|
|
|||
141
draw/gen.go
141
draw/gen.go
|
|
@ -27,12 +27,13 @@ func main() {
|
|||
"package draw\n\nimport (\n" +
|
||||
"\"image\"\n" +
|
||||
"\"image/color\"\n" +
|
||||
"\"math\"\n" +
|
||||
"\n" +
|
||||
"\"golang.org/x/image/math/f64\"\n" +
|
||||
")\n")
|
||||
|
||||
gen(w, "nnInterpolator", codeNNScaleLeaf)
|
||||
gen(w, "ablInterpolator", codeABLScaleLeaf)
|
||||
gen(w, "nnInterpolator", codeNNScaleLeaf, codeNNTransformLeaf)
|
||||
gen(w, "ablInterpolator", codeABLScaleLeaf, codeABLTransformLeaf)
|
||||
genKernel(w)
|
||||
|
||||
if *debug {
|
||||
|
|
@ -90,8 +91,9 @@ type data struct {
|
|||
receiver string
|
||||
}
|
||||
|
||||
func gen(w *bytes.Buffer, receiver string, code string) {
|
||||
func gen(w *bytes.Buffer, receiver string, codes ...string) {
|
||||
expn(w, codeRoot, &data{receiver: receiver})
|
||||
for _, code := range codes {
|
||||
for _, t := range dsTypes {
|
||||
expn(w, code, &data{
|
||||
dType: t.dType,
|
||||
|
|
@ -99,6 +101,7 @@ func gen(w *bytes.Buffer, receiver string, code string) {
|
|||
receiver: receiver,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func genKernel(w *bytes.Buffer) {
|
||||
|
|
@ -227,7 +230,7 @@ func expnDollar(prefix, dollar, suffix string, d *data) string {
|
|||
"dstColorRGBA64.G = uint16(%sg)\n"+
|
||||
"dstColorRGBA64.B = uint16(%sb)\n"+
|
||||
"dstColorRGBA64.A = uint16(%sa)\n"+
|
||||
"dst.Set(dr.Min.X+int(%s), dr.Min.Y+int(%s), dstColor)",
|
||||
"dst.Set(%s, %s, dstColor)",
|
||||
args[2], args[2], args[2], args[2],
|
||||
args[0], args[1],
|
||||
)
|
||||
|
|
@ -236,8 +239,7 @@ func expnDollar(prefix, dollar, suffix string, d *data) string {
|
|||
"dst.Pix[d+0] = uint8(uint32(%sr) >> 8)\n"+
|
||||
"dst.Pix[d+1] = uint8(uint32(%sg) >> 8)\n"+
|
||||
"dst.Pix[d+2] = uint8(uint32(%sb) >> 8)\n"+
|
||||
"dst.Pix[d+3] = uint8(uint32(%sa) >> 8)\n"+
|
||||
"d += 4",
|
||||
"dst.Pix[d+3] = uint8(uint32(%sa) >> 8)",
|
||||
args[2], args[2], args[2], args[2],
|
||||
)
|
||||
}
|
||||
|
|
@ -256,7 +258,7 @@ func expnDollar(prefix, dollar, suffix string, d *data) string {
|
|||
"dstColorRGBA64.G = ftou(%sg * %s)\n"+
|
||||
"dstColorRGBA64.B = ftou(%sb * %s)\n"+
|
||||
"dstColorRGBA64.A = ftou(%sa * %s)\n"+
|
||||
"dst.Set(dr.Min.X+int(%s), dr.Min.Y+int(%s), dstColor)",
|
||||
"dst.Set(%s, %s, dstColor)",
|
||||
args[2], args[3], args[2], args[3], args[2], args[3], args[2], args[3],
|
||||
args[0], args[1],
|
||||
)
|
||||
|
|
@ -292,14 +294,14 @@ func expnDollar(prefix, dollar, suffix string, d *data) string {
|
|||
log.Fatalf("bad sType %q", d.sType)
|
||||
case "image.Image", "*image.Gray", "*image.NRGBA", "*image.Uniform", "*image.YCbCr": // TODO: separate code for concrete types.
|
||||
fmt.Fprintf(buf, "%sr%s, %sg%s, %sb%s, %sa%s := "+
|
||||
"src.At(sr.Min.X + int(%s), sr.Min.Y+int(%s)).RGBA()\n",
|
||||
"src.At(%s, %s).RGBA()\n",
|
||||
lhs, tmp, lhs, tmp, lhs, tmp, lhs, tmp,
|
||||
args[0], args[1],
|
||||
)
|
||||
case "*image.RGBA":
|
||||
// TODO: there's no need to multiply by 0x101 if the next thing
|
||||
// we're going to do is shift right by 8.
|
||||
fmt.Fprintf(buf, "%si := src.PixOffset(sr.Min.X + int(%s), sr.Min.Y+int(%s))\n"+
|
||||
fmt.Fprintf(buf, "%si := src.PixOffset(%s, %s)\n"+
|
||||
"%sr%s := uint32(src.Pix[%si+0]) * 0x101\n"+
|
||||
"%sg%s := uint32(src.Pix[%si+1]) * 0x101\n"+
|
||||
"%sb%s := uint32(src.Pix[%si+2]) * 0x101\n"+
|
||||
|
|
@ -327,6 +329,12 @@ func expnDollar(prefix, dollar, suffix string, d *data) string {
|
|||
|
||||
return strings.TrimSpace(buf.String())
|
||||
|
||||
case "tweakDx":
|
||||
if d.dType == "*image.RGBA" {
|
||||
return strings.Replace(suffix, "dx++", "dx, d = dx+1, d+4", 1)
|
||||
}
|
||||
return suffix
|
||||
|
||||
case "tweakDy":
|
||||
if d.dType == "*image.RGBA" {
|
||||
return strings.Replace(suffix, "for dy, s", "for _, s", 1)
|
||||
|
|
@ -428,8 +436,15 @@ const (
|
|||
}
|
||||
}
|
||||
|
||||
func (z $receiver) Transform(dst Image, m *f64.Aff3, src image.Image, sr image.Rectangle, opts *Options) {
|
||||
panic("unimplemented")
|
||||
func (z $receiver) 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)
|
||||
z.transform_Image_Image(dst, dr, adr, &d2s, src, sr)
|
||||
}
|
||||
`
|
||||
|
||||
|
|
@ -443,10 +458,30 @@ const (
|
|||
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
|
||||
sy := (2*uint64(dy) + 1) * sh / dh2
|
||||
$preInner
|
||||
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
|
||||
$tweakDx for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
|
||||
sx := (2*uint64(dx) + 1) * sw / dw2
|
||||
p := $srcu[sx, sy]
|
||||
$outputu[dx, dy, p]
|
||||
p := $srcu[sr.Min.X + int(sx), sr.Min.Y + int(sy)]
|
||||
$outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p]
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
codeNNTransformLeaf = `
|
||||
func (nnInterpolator) transform_$dTypeRN_$sTypeRN(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle) {
|
||||
$preOuter
|
||||
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
|
||||
dyf := float64(dr.Min.Y + int(dy)) + 0.5
|
||||
$preInner
|
||||
$tweakDx 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
|
||||
}
|
||||
p := $srcu[sx0, sy0]
|
||||
$outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -458,9 +493,14 @@ const (
|
|||
sh := int32(sr.Dy())
|
||||
yscale := float64(sh) / float64(dr.Dy())
|
||||
xscale := float64(sw) / float64(dr.Dx())
|
||||
swMinus1, shMinus1 := sw - 1, sh - 1
|
||||
$preOuter
|
||||
|
||||
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
|
||||
sy := (float64(dy)+0.5)*yscale - 0.5
|
||||
// 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.
|
||||
sy0 := int32(sy)
|
||||
yFrac0 := sy - float64(sy0)
|
||||
yFrac1 := 1 - yFrac0
|
||||
|
|
@ -468,12 +508,13 @@ const (
|
|||
if sy < 0 {
|
||||
sy0, sy1 = 0, 0
|
||||
yFrac0, yFrac1 = 0, 1
|
||||
} else if sy1 >= sh {
|
||||
sy1 = sy0
|
||||
} else if sy1 > shMinus1 {
|
||||
sy0, sy1 = shMinus1, shMinus1
|
||||
yFrac0, yFrac1 = 1, 0
|
||||
}
|
||||
$preInner
|
||||
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
|
||||
|
||||
$tweakDx for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
|
||||
sx := (float64(dx)+0.5)*xscale - 0.5
|
||||
sx0 := int32(sx)
|
||||
xFrac0 := sx - float64(sx0)
|
||||
|
|
@ -482,10 +523,66 @@ const (
|
|||
if sx < 0 {
|
||||
sx0, sx1 = 0, 0
|
||||
xFrac0, xFrac1 = 0, 1
|
||||
} else if sx1 >= sw {
|
||||
sx1 = sx0
|
||||
} else if sx1 > swMinus1 {
|
||||
sx0, sx1 = swMinus1, swMinus1
|
||||
xFrac0, xFrac1 = 1, 0
|
||||
}
|
||||
|
||||
s00 := $srcf[sr.Min.X + int(sx0), sr.Min.Y + int(sy0)]
|
||||
s10 := $srcf[sr.Min.X + int(sx1), sr.Min.Y + int(sy0)]
|
||||
$blend[xFrac1, s00, xFrac0, s10]
|
||||
s01 := $srcf[sr.Min.X + int(sx0), sr.Min.Y + int(sy1)]
|
||||
s11 := $srcf[sr.Min.X + int(sx1), sr.Min.Y + int(sy1)]
|
||||
$blend[xFrac1, s01, xFrac0, s11]
|
||||
$blend[yFrac1, s10, yFrac0, s11]
|
||||
$outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), s11]
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
|
||||
codeABLTransformLeaf = `
|
||||
func (ablInterpolator) transform_$dTypeRN_$sTypeRN(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle) {
|
||||
$preOuter
|
||||
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
|
||||
dyf := float64(dr.Min.Y + int(dy)) + 0.5
|
||||
$preInner
|
||||
$tweakDx 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
|
||||
}
|
||||
|
||||
s00 := $srcf[sx0, sy0]
|
||||
s10 := $srcf[sx1, sy0]
|
||||
$blend[xFrac1, s00, xFrac0, s10]
|
||||
|
|
@ -493,7 +590,7 @@ const (
|
|||
s11 := $srcf[sx1, sy1]
|
||||
$blend[xFrac1, s01, xFrac0, s11]
|
||||
$blend[yFrac1, s10, yFrac0, s11]
|
||||
$outputu[dx, dy, s11]
|
||||
$outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), s11]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -540,7 +637,7 @@ const (
|
|||
for _, s := range z.horizontal.sources {
|
||||
var pr, pg, pb, pa float64
|
||||
for _, c := range z.horizontal.contribs[s.i:s.j] {
|
||||
p += $srcf[c.coord, y] * c.weight
|
||||
p += $srcf[sr.Min.X + int(c.coord), sr.Min.Y + int(y)] * c.weight
|
||||
}
|
||||
tmp[t] = [4]float64{
|
||||
pr * s.invTotalWeightFFFF,
|
||||
|
|
@ -568,7 +665,7 @@ const (
|
|||
pb += p[2] * c.weight
|
||||
pa += p[3] * c.weight
|
||||
}
|
||||
$outputf[dx, adr.Min.Y+dy, p, s.invTotalWeight]
|
||||
$outputf[dr.Min.X + int(dx), dr.Min.Y + int(adr.Min.Y + dy), p, s.invTotalWeight]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
888
draw/impl.go
888
draw/impl.go
File diff suppressed because it is too large
Load Diff
|
|
@ -249,3 +249,72 @@ func ftou(f float64) uint16 {
|
|||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// invert returns the inverse of m.
|
||||
//
|
||||
// TODO: move this into the f64 package, once we work out the convention for
|
||||
// matrix methods in that package: do they modify the receiver, take a dst
|
||||
// pointer argument, or return a new value?
|
||||
func invert(m *f64.Aff3) f64.Aff3 {
|
||||
m00 := +m[3*1+1]
|
||||
m01 := -m[3*0+1]
|
||||
m02 := +m[3*1+2]*m[3*0+1] - m[3*1+1]*m[3*0+2]
|
||||
m10 := -m[3*1+0]
|
||||
m11 := +m[3*0+0]
|
||||
m12 := +m[3*1+0]*m[3*0+2] - m[3*1+2]*m[3*0+0]
|
||||
|
||||
det := m00*m11 - m10*m01
|
||||
|
||||
return f64.Aff3{
|
||||
m00 / det,
|
||||
m01 / det,
|
||||
m02 / det,
|
||||
m10 / det,
|
||||
m11 / det,
|
||||
m12 / det,
|
||||
}
|
||||
}
|
||||
|
||||
// transformRect returns a rectangle dr that contains sr transformed by s2d.
|
||||
func transformRect(s2d *f64.Aff3, sr *image.Rectangle) (dr image.Rectangle) {
|
||||
ps := [...]image.Point{
|
||||
{sr.Min.X, sr.Min.Y},
|
||||
{sr.Max.X, sr.Min.Y},
|
||||
{sr.Min.X, sr.Max.Y},
|
||||
{sr.Max.X, sr.Max.Y},
|
||||
}
|
||||
for i, p := range ps {
|
||||
sxf := float64(p.X)
|
||||
syf := float64(p.Y)
|
||||
dx := int(math.Floor(s2d[0]*sxf + s2d[1]*syf + s2d[2]))
|
||||
dy := int(math.Floor(s2d[3]*sxf + s2d[4]*syf + s2d[5]))
|
||||
|
||||
// The +1 adjustments below are because an image.Rectangle is inclusive
|
||||
// on the low end but exclusive on the high end.
|
||||
|
||||
if i == 0 {
|
||||
dr = image.Rectangle{
|
||||
Min: image.Point{dx + 0, dy + 0},
|
||||
Max: image.Point{dx + 1, dy + 1},
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if dr.Min.X > dx {
|
||||
dr.Min.X = dx
|
||||
}
|
||||
dx++
|
||||
if dr.Max.X < dx {
|
||||
dr.Max.X = dx
|
||||
}
|
||||
|
||||
if dr.Min.Y > dy {
|
||||
dr.Min.Y = dy
|
||||
}
|
||||
dy++
|
||||
if dr.Max.Y < dy {
|
||||
dr.Max.Y = dy
|
||||
}
|
||||
}
|
||||
return dr
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,18 +16,28 @@ import (
|
|||
"reflect"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/image/math/f64"
|
||||
|
||||
_ "image/jpeg"
|
||||
)
|
||||
|
||||
var genScaleFiles = flag.Bool("gen_scale_files", false, "whether to generate the TestScaleXxx golden files.")
|
||||
var genGoldenFiles = flag.Bool("gen_golden_files", false, "whether to generate the TestXxx golden files.")
|
||||
|
||||
// testScale tests that scaling the source image gives the exact destination
|
||||
// image. This is to ensure that any refactoring or optimization of the scaling
|
||||
// code doesn't change the scaling behavior. Changing the actual algorithm or
|
||||
// kernel used by any particular quality setting will obviously change the
|
||||
// resultant pixels. In such a case, use the gen_scale_files flag to regenerate
|
||||
// the golden files.
|
||||
func testScale(t *testing.T, w int, h int, direction, srcFilename string) {
|
||||
var transformMatrix = func() *f64.Aff3 {
|
||||
const scale, cos30, sin30 = 3.75, 0.866025404, 0.5
|
||||
return &f64.Aff3{
|
||||
+scale * cos30, -scale * sin30, 40,
|
||||
+scale * sin30, +scale * cos30, 10,
|
||||
}
|
||||
}()
|
||||
|
||||
// testInterp tests that interpolating the source image gives the exact
|
||||
// destination image. This is to ensure that any refactoring or optimization of
|
||||
// the interpolation code doesn't change the behavior. Changing the actual
|
||||
// algorithm or kernel used by any particular quality setting will obviously
|
||||
// change the resultant pixels. In such a case, use the gen_golden_files flag
|
||||
// to regenerate the golden files.
|
||||
func testInterp(t *testing.T, w int, h int, direction, srcFilename string) {
|
||||
f, err := os.Open("../testdata/go-turns-two-" + srcFilename)
|
||||
if err != nil {
|
||||
t.Fatalf("Open: %v", err)
|
||||
|
|
@ -44,12 +54,21 @@ func testScale(t *testing.T, w int, h int, direction, srcFilename string) {
|
|||
"cr": CatmullRom,
|
||||
}
|
||||
for name, q := range testCases {
|
||||
gotFilename := fmt.Sprintf("../testdata/go-turns-two-%s-%s.png", direction, name)
|
||||
goldenFilename := fmt.Sprintf("../testdata/go-turns-two-%s-%s.png", direction, name)
|
||||
|
||||
got := image.NewRGBA(image.Rect(0, 0, w, h))
|
||||
if direction == "rotate" {
|
||||
if name == "bl" || name == "cr" {
|
||||
// TODO: implement Kernel.Transform.
|
||||
continue
|
||||
}
|
||||
q.Transform(got, transformMatrix, src, src.Bounds(), nil)
|
||||
} else {
|
||||
q.Scale(got, got.Bounds(), src, src.Bounds(), nil)
|
||||
if *genScaleFiles {
|
||||
g, err := os.Create(gotFilename)
|
||||
}
|
||||
|
||||
if *genGoldenFiles {
|
||||
g, err := os.Create(goldenFilename)
|
||||
if err != nil {
|
||||
t.Errorf("Create: %v", err)
|
||||
continue
|
||||
|
|
@ -62,27 +81,35 @@ func testScale(t *testing.T, w int, h int, direction, srcFilename string) {
|
|||
continue
|
||||
}
|
||||
|
||||
g, err := os.Open(gotFilename)
|
||||
g, err := os.Open(goldenFilename)
|
||||
if err != nil {
|
||||
t.Errorf("Open: %v", err)
|
||||
continue
|
||||
}
|
||||
defer g.Close()
|
||||
want, err := png.Decode(g)
|
||||
wantRaw, err := png.Decode(g)
|
||||
if err != nil {
|
||||
t.Errorf("Decode: %v", err)
|
||||
continue
|
||||
}
|
||||
// convert wantRaw to RGBA.
|
||||
want, ok := wantRaw.(*image.RGBA)
|
||||
if !ok {
|
||||
b := wantRaw.Bounds()
|
||||
want = image.NewRGBA(b)
|
||||
Draw(want, b, wantRaw, b.Min, Src)
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("%s: actual image differs from golden image", gotFilename)
|
||||
t.Errorf("%s: actual image differs from golden image", goldenFilename)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestScaleDown(t *testing.T) { testScale(t, 100, 100, "down", "280x360.jpeg") }
|
||||
func TestScaleUp(t *testing.T) { testScale(t, 75, 100, "up", "14x18.png") }
|
||||
func TestScaleDown(t *testing.T) { testInterp(t, 100, 100, "down", "280x360.jpeg") }
|
||||
func TestScaleUp(t *testing.T) { testInterp(t, 75, 100, "up", "14x18.png") }
|
||||
func TestTransform(t *testing.T) { testInterp(t, 100, 100, "rotate", "14x18.png") }
|
||||
|
||||
func fillPix(r *rand.Rand, pixs ...[]byte) {
|
||||
for _, pix := range pixs {
|
||||
|
|
@ -92,7 +119,7 @@ func fillPix(r *rand.Rand, pixs ...[]byte) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestScaleClipCommute(t *testing.T) {
|
||||
func TestInterpClipCommute(t *testing.T) {
|
||||
src := image.NewNRGBA(image.Rect(0, 0, 20, 20))
|
||||
fillPix(rand.New(rand.NewSource(0)), src.Pix)
|
||||
|
||||
|
|
@ -103,7 +130,13 @@ func TestScaleClipCommute(t *testing.T) {
|
|||
ApproxBiLinear,
|
||||
CatmullRom,
|
||||
}
|
||||
for _, transform := range []bool{false, true} {
|
||||
for _, q := range qs {
|
||||
if transform && q == CatmullRom {
|
||||
// TODO: implement Kernel.Transform.
|
||||
continue
|
||||
}
|
||||
|
||||
dst0 := image.NewRGBA(image.Rect(1, 1, 10, 10))
|
||||
dst1 := image.NewRGBA(image.Rect(1, 1, 10, 10))
|
||||
for i := range dst0.Pix {
|
||||
|
|
@ -111,13 +144,24 @@ func TestScaleClipCommute(t *testing.T) {
|
|||
dst1.Pix[i] = uint8(i / 4)
|
||||
}
|
||||
|
||||
// Scale then clip.
|
||||
q.Scale(dst0, outer, src, src.Bounds(), nil)
|
||||
var interp func(dst *image.RGBA)
|
||||
if transform {
|
||||
interp = func(dst *image.RGBA) {
|
||||
q.Transform(dst, transformMatrix, src, src.Bounds(), nil)
|
||||
}
|
||||
} else {
|
||||
interp = func(dst *image.RGBA) {
|
||||
q.Scale(dst, outer, src, src.Bounds(), nil)
|
||||
}
|
||||
}
|
||||
|
||||
// Interpolate then clip.
|
||||
interp(dst0)
|
||||
dst0 = dst0.SubImage(inner).(*image.RGBA)
|
||||
|
||||
// Clip then scale.
|
||||
// Clip then interpolate.
|
||||
dst1 = dst1.SubImage(inner).(*image.RGBA)
|
||||
q.Scale(dst1, outer, src, src.Bounds(), nil)
|
||||
interp(dst1)
|
||||
|
||||
loop:
|
||||
for y := inner.Min.Y; y < inner.Max.Y; y++ {
|
||||
|
|
@ -129,6 +173,7 @@ func TestScaleClipCommute(t *testing.T) {
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// translatedImage is an image m translated by t.
|
||||
|
|
@ -184,7 +229,7 @@ func TestSrcTranslationInvariance(t *testing.T) {
|
|||
t.Errorf("pix differ for delta=%v, q=%T", delta, q)
|
||||
}
|
||||
|
||||
// TODO: Transform.
|
||||
// TODO: Transform, once Kernel.Transform is implemented.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -250,6 +295,8 @@ func TestFastPaths(t *testing.T) {
|
|||
if !bytes.Equal(dst0.Pix, dst1.Pix) {
|
||||
t.Errorf("pix differ for dr=%v, src=%T, sr=%v, q=%T", dr, src, sr, q)
|
||||
}
|
||||
|
||||
// TODO: Transform, once Kernel.Transform is implemented.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -331,6 +378,20 @@ func benchScale(b *testing.B, srcf func(image.Rectangle) (image.Image, error), w
|
|||
}
|
||||
}
|
||||
|
||||
func benchTform(b *testing.B, srcf func(image.Rectangle) (image.Image, error), w int, h int, q Interpolator) {
|
||||
dst := image.NewRGBA(image.Rect(0, 0, w, h))
|
||||
src, err := srcf(image.Rect(0, 0, 1024, 768))
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
sr := src.Bounds()
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
q.Transform(dst, transformMatrix, src, sr, nil)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkScaleLargeDownNN(b *testing.B) { benchScale(b, srcYCbCrLarge, 200, 150, NearestNeighbor) }
|
||||
func BenchmarkScaleLargeDownAB(b *testing.B) { benchScale(b, srcYCbCrLarge, 200, 150, ApproxBiLinear) }
|
||||
func BenchmarkScaleLargeDownBL(b *testing.B) { benchScale(b, srcYCbCrLarge, 200, 150, BiLinear) }
|
||||
|
|
@ -351,3 +412,9 @@ func BenchmarkScaleSrcNRGBA(b *testing.B) { benchScale(b, srcNRGBA, 200, 150,
|
|||
func BenchmarkScaleSrcRGBA(b *testing.B) { benchScale(b, srcRGBA, 200, 150, ApproxBiLinear) }
|
||||
func BenchmarkScaleSrcUniform(b *testing.B) { benchScale(b, srcUniform, 200, 150, ApproxBiLinear) }
|
||||
func BenchmarkScaleSrcYCbCr(b *testing.B) { benchScale(b, srcYCbCr, 200, 150, ApproxBiLinear) }
|
||||
|
||||
func BenchmarkTformSrcGray(b *testing.B) { benchTform(b, srcGray, 200, 150, ApproxBiLinear) }
|
||||
func BenchmarkTformSrcNRGBA(b *testing.B) { benchTform(b, srcNRGBA, 200, 150, ApproxBiLinear) }
|
||||
func BenchmarkTformSrcRGBA(b *testing.B) { benchTform(b, srcRGBA, 200, 150, ApproxBiLinear) }
|
||||
func BenchmarkTformSrcUniform(b *testing.B) { benchTform(b, srcUniform, 200, 150, ApproxBiLinear) }
|
||||
func BenchmarkTformSrcYCbCr(b *testing.B) { benchTform(b, srcYCbCr, 200, 150, ApproxBiLinear) }
|
||||
|
|
|
|||
BIN
testdata/go-turns-two-rotate-ab.png
vendored
Normal file
BIN
testdata/go-turns-two-rotate-ab.png
vendored
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 8.6 KiB |
BIN
testdata/go-turns-two-rotate-nn.png
vendored
Normal file
BIN
testdata/go-turns-two-rotate-nn.png
vendored
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 4.9 KiB |
Loading…
Reference in New Issue
Block a user