Source file src/image/draw/draw_test.go

Documentation: image/draw

		 1  // Copyright 2010 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package draw
		 6  
		 7  import (
		 8  	"image"
		 9  	"image/color"
		10  	"image/png"
		11  	"os"
		12  	"testing"
		13  	"testing/quick"
		14  )
		15  
		16  func eq(c0, c1 color.Color) bool {
		17  	r0, g0, b0, a0 := c0.RGBA()
		18  	r1, g1, b1, a1 := c1.RGBA()
		19  	return r0 == r1 && g0 == g1 && b0 == b1 && a0 == a1
		20  }
		21  
		22  func fillBlue(alpha int) image.Image {
		23  	return image.NewUniform(color.RGBA{0, 0, uint8(alpha), uint8(alpha)})
		24  }
		25  
		26  func fillAlpha(alpha int) image.Image {
		27  	return image.NewUniform(color.Alpha{uint8(alpha)})
		28  }
		29  
		30  func vgradGreen(alpha int) image.Image {
		31  	m := image.NewRGBA(image.Rect(0, 0, 16, 16))
		32  	for y := 0; y < 16; y++ {
		33  		for x := 0; x < 16; x++ {
		34  			m.Set(x, y, color.RGBA{0, uint8(y * alpha / 15), 0, uint8(alpha)})
		35  		}
		36  	}
		37  	return m
		38  }
		39  
		40  func vgradAlpha(alpha int) image.Image {
		41  	m := image.NewAlpha(image.Rect(0, 0, 16, 16))
		42  	for y := 0; y < 16; y++ {
		43  		for x := 0; x < 16; x++ {
		44  			m.Set(x, y, color.Alpha{uint8(y * alpha / 15)})
		45  		}
		46  	}
		47  	return m
		48  }
		49  
		50  func vgradGreenNRGBA(alpha int) image.Image {
		51  	m := image.NewNRGBA(image.Rect(0, 0, 16, 16))
		52  	for y := 0; y < 16; y++ {
		53  		for x := 0; x < 16; x++ {
		54  			m.Set(x, y, color.RGBA{0, uint8(y * 0x11), 0, uint8(alpha)})
		55  		}
		56  	}
		57  	return m
		58  }
		59  
		60  func vgradCr() image.Image {
		61  	m := &image.YCbCr{
		62  		Y:							make([]byte, 16*16),
		63  		Cb:						 make([]byte, 16*16),
		64  		Cr:						 make([]byte, 16*16),
		65  		YStride:				16,
		66  		CStride:				16,
		67  		SubsampleRatio: image.YCbCrSubsampleRatio444,
		68  		Rect:					 image.Rect(0, 0, 16, 16),
		69  	}
		70  	for y := 0; y < 16; y++ {
		71  		for x := 0; x < 16; x++ {
		72  			m.Cr[y*m.CStride+x] = uint8(y * 0x11)
		73  		}
		74  	}
		75  	return m
		76  }
		77  
		78  func vgradGray() image.Image {
		79  	m := image.NewGray(image.Rect(0, 0, 16, 16))
		80  	for y := 0; y < 16; y++ {
		81  		for x := 0; x < 16; x++ {
		82  			m.Set(x, y, color.Gray{uint8(y * 0x11)})
		83  		}
		84  	}
		85  	return m
		86  }
		87  
		88  func vgradMagenta() image.Image {
		89  	m := image.NewCMYK(image.Rect(0, 0, 16, 16))
		90  	for y := 0; y < 16; y++ {
		91  		for x := 0; x < 16; x++ {
		92  			m.Set(x, y, color.CMYK{0, uint8(y * 0x11), 0, 0x3f})
		93  		}
		94  	}
		95  	return m
		96  }
		97  
		98  func hgradRed(alpha int) Image {
		99  	m := image.NewRGBA(image.Rect(0, 0, 16, 16))
	 100  	for y := 0; y < 16; y++ {
	 101  		for x := 0; x < 16; x++ {
	 102  			m.Set(x, y, color.RGBA{uint8(x * alpha / 15), 0, 0, uint8(alpha)})
	 103  		}
	 104  	}
	 105  	return m
	 106  }
	 107  
	 108  func gradYellow(alpha int) Image {
	 109  	m := image.NewRGBA(image.Rect(0, 0, 16, 16))
	 110  	for y := 0; y < 16; y++ {
	 111  		for x := 0; x < 16; x++ {
	 112  			m.Set(x, y, color.RGBA{uint8(x * alpha / 15), uint8(y * alpha / 15), 0, uint8(alpha)})
	 113  		}
	 114  	}
	 115  	return m
	 116  }
	 117  
	 118  type drawTest struct {
	 119  	desc		 string
	 120  	src			image.Image
	 121  	mask		 image.Image
	 122  	op			 Op
	 123  	expected color.Color
	 124  }
	 125  
	 126  var drawTests = []drawTest{
	 127  	// Uniform mask (0% opaque).
	 128  	{"nop", vgradGreen(255), fillAlpha(0), Over, color.RGBA{136, 0, 0, 255}},
	 129  	{"clear", vgradGreen(255), fillAlpha(0), Src, color.RGBA{0, 0, 0, 0}},
	 130  	// Uniform mask (100%, 75%, nil) and uniform source.
	 131  	// At (x, y) == (8, 8):
	 132  	// The destination pixel is {136, 0, 0, 255}.
	 133  	// The source pixel is {0, 0, 90, 90}.
	 134  	{"fill", fillBlue(90), fillAlpha(255), Over, color.RGBA{88, 0, 90, 255}},
	 135  	{"fillSrc", fillBlue(90), fillAlpha(255), Src, color.RGBA{0, 0, 90, 90}},
	 136  	{"fillAlpha", fillBlue(90), fillAlpha(192), Over, color.RGBA{100, 0, 68, 255}},
	 137  	{"fillAlphaSrc", fillBlue(90), fillAlpha(192), Src, color.RGBA{0, 0, 68, 68}},
	 138  	{"fillNil", fillBlue(90), nil, Over, color.RGBA{88, 0, 90, 255}},
	 139  	{"fillNilSrc", fillBlue(90), nil, Src, color.RGBA{0, 0, 90, 90}},
	 140  	// Uniform mask (100%, 75%, nil) and variable source.
	 141  	// At (x, y) == (8, 8):
	 142  	// The destination pixel is {136, 0, 0, 255}.
	 143  	// The source pixel is {0, 48, 0, 90}.
	 144  	{"copy", vgradGreen(90), fillAlpha(255), Over, color.RGBA{88, 48, 0, 255}},
	 145  	{"copySrc", vgradGreen(90), fillAlpha(255), Src, color.RGBA{0, 48, 0, 90}},
	 146  	{"copyAlpha", vgradGreen(90), fillAlpha(192), Over, color.RGBA{100, 36, 0, 255}},
	 147  	{"copyAlphaSrc", vgradGreen(90), fillAlpha(192), Src, color.RGBA{0, 36, 0, 68}},
	 148  	{"copyNil", vgradGreen(90), nil, Over, color.RGBA{88, 48, 0, 255}},
	 149  	{"copyNilSrc", vgradGreen(90), nil, Src, color.RGBA{0, 48, 0, 90}},
	 150  	// Uniform mask (100%, 75%, nil) and variable NRGBA source.
	 151  	// At (x, y) == (8, 8):
	 152  	// The destination pixel is {136, 0, 0, 255}.
	 153  	// The source pixel is {0, 136, 0, 90} in NRGBA-space, which is {0, 48, 0, 90} in RGBA-space.
	 154  	// The result pixel is different than in the "copy*" test cases because of rounding errors.
	 155  	{"nrgba", vgradGreenNRGBA(90), fillAlpha(255), Over, color.RGBA{88, 46, 0, 255}},
	 156  	{"nrgbaSrc", vgradGreenNRGBA(90), fillAlpha(255), Src, color.RGBA{0, 46, 0, 90}},
	 157  	{"nrgbaAlpha", vgradGreenNRGBA(90), fillAlpha(192), Over, color.RGBA{100, 34, 0, 255}},
	 158  	{"nrgbaAlphaSrc", vgradGreenNRGBA(90), fillAlpha(192), Src, color.RGBA{0, 34, 0, 68}},
	 159  	{"nrgbaNil", vgradGreenNRGBA(90), nil, Over, color.RGBA{88, 46, 0, 255}},
	 160  	{"nrgbaNilSrc", vgradGreenNRGBA(90), nil, Src, color.RGBA{0, 46, 0, 90}},
	 161  	// Uniform mask (100%, 75%, nil) and variable YCbCr source.
	 162  	// At (x, y) == (8, 8):
	 163  	// The destination pixel is {136, 0, 0, 255}.
	 164  	// The source pixel is {0, 0, 136} in YCbCr-space, which is {11, 38, 0, 255} in RGB-space.
	 165  	{"ycbcr", vgradCr(), fillAlpha(255), Over, color.RGBA{11, 38, 0, 255}},
	 166  	{"ycbcrSrc", vgradCr(), fillAlpha(255), Src, color.RGBA{11, 38, 0, 255}},
	 167  	{"ycbcrAlpha", vgradCr(), fillAlpha(192), Over, color.RGBA{42, 28, 0, 255}},
	 168  	{"ycbcrAlphaSrc", vgradCr(), fillAlpha(192), Src, color.RGBA{8, 28, 0, 192}},
	 169  	{"ycbcrNil", vgradCr(), nil, Over, color.RGBA{11, 38, 0, 255}},
	 170  	{"ycbcrNilSrc", vgradCr(), nil, Src, color.RGBA{11, 38, 0, 255}},
	 171  	// Uniform mask (100%, 75%, nil) and variable Gray source.
	 172  	// At (x, y) == (8, 8):
	 173  	// The destination pixel is {136, 0, 0, 255}.
	 174  	// The source pixel is {136} in Gray-space, which is {136, 136, 136, 255} in RGBA-space.
	 175  	{"gray", vgradGray(), fillAlpha(255), Over, color.RGBA{136, 136, 136, 255}},
	 176  	{"graySrc", vgradGray(), fillAlpha(255), Src, color.RGBA{136, 136, 136, 255}},
	 177  	{"grayAlpha", vgradGray(), fillAlpha(192), Over, color.RGBA{136, 102, 102, 255}},
	 178  	{"grayAlphaSrc", vgradGray(), fillAlpha(192), Src, color.RGBA{102, 102, 102, 192}},
	 179  	{"grayNil", vgradGray(), nil, Over, color.RGBA{136, 136, 136, 255}},
	 180  	{"grayNilSrc", vgradGray(), nil, Src, color.RGBA{136, 136, 136, 255}},
	 181  	// Uniform mask (100%, 75%, nil) and variable CMYK source.
	 182  	// At (x, y) == (8, 8):
	 183  	// The destination pixel is {136, 0, 0, 255}.
	 184  	// The source pixel is {0, 136, 0, 63} in CMYK-space, which is {192, 89, 192} in RGB-space.
	 185  	{"cmyk", vgradMagenta(), fillAlpha(255), Over, color.RGBA{192, 89, 192, 255}},
	 186  	{"cmykSrc", vgradMagenta(), fillAlpha(255), Src, color.RGBA{192, 89, 192, 255}},
	 187  	{"cmykAlpha", vgradMagenta(), fillAlpha(192), Over, color.RGBA{178, 67, 145, 255}},
	 188  	{"cmykAlphaSrc", vgradMagenta(), fillAlpha(192), Src, color.RGBA{145, 67, 145, 192}},
	 189  	{"cmykNil", vgradMagenta(), nil, Over, color.RGBA{192, 89, 192, 255}},
	 190  	{"cmykNilSrc", vgradMagenta(), nil, Src, color.RGBA{192, 89, 192, 255}},
	 191  	// Variable mask and variable source.
	 192  	// At (x, y) == (8, 8):
	 193  	// The destination pixel is {136, 0, 0, 255}.
	 194  	// The source pixel is {0, 0, 255, 255}.
	 195  	// The mask pixel's alpha is 102, or 40%.
	 196  	{"generic", fillBlue(255), vgradAlpha(192), Over, color.RGBA{81, 0, 102, 255}},
	 197  	{"genericSrc", fillBlue(255), vgradAlpha(192), Src, color.RGBA{0, 0, 102, 102}},
	 198  }
	 199  
	 200  func makeGolden(dst image.Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) image.Image {
	 201  	// Since golden is a newly allocated image, we don't have to check if the
	 202  	// input source and mask images and the output golden image overlap.
	 203  	b := dst.Bounds()
	 204  	sb := src.Bounds()
	 205  	mb := image.Rect(-1e9, -1e9, 1e9, 1e9)
	 206  	if mask != nil {
	 207  		mb = mask.Bounds()
	 208  	}
	 209  	golden := image.NewRGBA(image.Rect(0, 0, b.Max.X, b.Max.Y))
	 210  	for y := r.Min.Y; y < r.Max.Y; y++ {
	 211  		sy := y + sp.Y - r.Min.Y
	 212  		my := y + mp.Y - r.Min.Y
	 213  		for x := r.Min.X; x < r.Max.X; x++ {
	 214  			if !(image.Pt(x, y).In(b)) {
	 215  				continue
	 216  			}
	 217  			sx := x + sp.X - r.Min.X
	 218  			if !(image.Pt(sx, sy).In(sb)) {
	 219  				continue
	 220  			}
	 221  			mx := x + mp.X - r.Min.X
	 222  			if !(image.Pt(mx, my).In(mb)) {
	 223  				continue
	 224  			}
	 225  
	 226  			const M = 1<<16 - 1
	 227  			var dr, dg, db, da uint32
	 228  			if op == Over {
	 229  				dr, dg, db, da = dst.At(x, y).RGBA()
	 230  			}
	 231  			sr, sg, sb, sa := src.At(sx, sy).RGBA()
	 232  			ma := uint32(M)
	 233  			if mask != nil {
	 234  				_, _, _, ma = mask.At(mx, my).RGBA()
	 235  			}
	 236  			a := M - (sa * ma / M)
	 237  			golden.Set(x, y, color.RGBA64{
	 238  				uint16((dr*a + sr*ma) / M),
	 239  				uint16((dg*a + sg*ma) / M),
	 240  				uint16((db*a + sb*ma) / M),
	 241  				uint16((da*a + sa*ma) / M),
	 242  			})
	 243  		}
	 244  	}
	 245  	return golden.SubImage(b)
	 246  }
	 247  
	 248  func TestDraw(t *testing.T) {
	 249  	rr := []image.Rectangle{
	 250  		image.Rect(0, 0, 0, 0),
	 251  		image.Rect(0, 0, 16, 16),
	 252  		image.Rect(3, 5, 12, 10),
	 253  		image.Rect(0, 0, 9, 9),
	 254  		image.Rect(8, 8, 16, 16),
	 255  		image.Rect(8, 0, 9, 16),
	 256  		image.Rect(0, 8, 16, 9),
	 257  		image.Rect(8, 8, 9, 9),
	 258  		image.Rect(8, 8, 8, 8),
	 259  	}
	 260  	for _, r := range rr {
	 261  	loop:
	 262  		for _, test := range drawTests {
	 263  			dst := hgradRed(255).(*image.RGBA).SubImage(r).(Image)
	 264  			// Draw the (src, mask, op) onto a copy of dst using a slow but obviously correct implementation.
	 265  			golden := makeGolden(dst, image.Rect(0, 0, 16, 16), test.src, image.ZP, test.mask, image.ZP, test.op)
	 266  			b := dst.Bounds()
	 267  			if !b.Eq(golden.Bounds()) {
	 268  				t.Errorf("draw %v %s: bounds %v versus %v", r, test.desc, dst.Bounds(), golden.Bounds())
	 269  				continue
	 270  			}
	 271  			// Draw the same combination onto the actual dst using the optimized DrawMask implementation.
	 272  			DrawMask(dst, image.Rect(0, 0, 16, 16), test.src, image.ZP, test.mask, image.ZP, test.op)
	 273  			if image.Pt(8, 8).In(r) {
	 274  				// Check that the resultant pixel at (8, 8) matches what we expect
	 275  				// (the expected value can be verified by hand).
	 276  				if !eq(dst.At(8, 8), test.expected) {
	 277  					t.Errorf("draw %v %s: at (8, 8) %v versus %v", r, test.desc, dst.At(8, 8), test.expected)
	 278  					continue
	 279  				}
	 280  			}
	 281  			// Check that the resultant dst image matches the golden output.
	 282  			for y := b.Min.Y; y < b.Max.Y; y++ {
	 283  				for x := b.Min.X; x < b.Max.X; x++ {
	 284  					if !eq(dst.At(x, y), golden.At(x, y)) {
	 285  						t.Errorf("draw %v %s: at (%d, %d), %v versus golden %v", r, test.desc, x, y, dst.At(x, y), golden.At(x, y))
	 286  						continue loop
	 287  					}
	 288  				}
	 289  			}
	 290  		}
	 291  	}
	 292  }
	 293  
	 294  func TestDrawOverlap(t *testing.T) {
	 295  	for _, op := range []Op{Over, Src} {
	 296  		for yoff := -2; yoff <= 2; yoff++ {
	 297  		loop:
	 298  			for xoff := -2; xoff <= 2; xoff++ {
	 299  				m := gradYellow(127).(*image.RGBA)
	 300  				dst := m.SubImage(image.Rect(5, 5, 10, 10)).(*image.RGBA)
	 301  				src := m.SubImage(image.Rect(5+xoff, 5+yoff, 10+xoff, 10+yoff)).(*image.RGBA)
	 302  				b := dst.Bounds()
	 303  				// Draw the (src, mask, op) onto a copy of dst using a slow but obviously correct implementation.
	 304  				golden := makeGolden(dst, b, src, src.Bounds().Min, nil, image.ZP, op)
	 305  				if !b.Eq(golden.Bounds()) {
	 306  					t.Errorf("drawOverlap xoff=%d,yoff=%d: bounds %v versus %v", xoff, yoff, dst.Bounds(), golden.Bounds())
	 307  					continue
	 308  				}
	 309  				// Draw the same combination onto the actual dst using the optimized DrawMask implementation.
	 310  				DrawMask(dst, b, src, src.Bounds().Min, nil, image.ZP, op)
	 311  				// Check that the resultant dst image matches the golden output.
	 312  				for y := b.Min.Y; y < b.Max.Y; y++ {
	 313  					for x := b.Min.X; x < b.Max.X; x++ {
	 314  						if !eq(dst.At(x, y), golden.At(x, y)) {
	 315  							t.Errorf("drawOverlap xoff=%d,yoff=%d: at (%d, %d), %v versus golden %v", xoff, yoff, x, y, dst.At(x, y), golden.At(x, y))
	 316  							continue loop
	 317  						}
	 318  					}
	 319  				}
	 320  			}
	 321  		}
	 322  	}
	 323  }
	 324  
	 325  // TestNonZeroSrcPt checks drawing with a non-zero src point parameter.
	 326  func TestNonZeroSrcPt(t *testing.T) {
	 327  	a := image.NewRGBA(image.Rect(0, 0, 1, 1))
	 328  	b := image.NewRGBA(image.Rect(0, 0, 2, 2))
	 329  	b.Set(0, 0, color.RGBA{0, 0, 0, 5})
	 330  	b.Set(1, 0, color.RGBA{0, 0, 5, 5})
	 331  	b.Set(0, 1, color.RGBA{0, 5, 0, 5})
	 332  	b.Set(1, 1, color.RGBA{5, 0, 0, 5})
	 333  	Draw(a, image.Rect(0, 0, 1, 1), b, image.Pt(1, 1), Over)
	 334  	if !eq(color.RGBA{5, 0, 0, 5}, a.At(0, 0)) {
	 335  		t.Errorf("non-zero src pt: want %v got %v", color.RGBA{5, 0, 0, 5}, a.At(0, 0))
	 336  	}
	 337  }
	 338  
	 339  func TestFill(t *testing.T) {
	 340  	rr := []image.Rectangle{
	 341  		image.Rect(0, 0, 0, 0),
	 342  		image.Rect(0, 0, 40, 30),
	 343  		image.Rect(10, 0, 40, 30),
	 344  		image.Rect(0, 20, 40, 30),
	 345  		image.Rect(10, 20, 40, 30),
	 346  		image.Rect(10, 20, 15, 25),
	 347  		image.Rect(10, 0, 35, 30),
	 348  		image.Rect(0, 15, 40, 16),
	 349  		image.Rect(24, 24, 25, 25),
	 350  		image.Rect(23, 23, 26, 26),
	 351  		image.Rect(22, 22, 27, 27),
	 352  		image.Rect(21, 21, 28, 28),
	 353  		image.Rect(20, 20, 29, 29),
	 354  	}
	 355  	for _, r := range rr {
	 356  		m := image.NewRGBA(image.Rect(0, 0, 40, 30)).SubImage(r).(*image.RGBA)
	 357  		b := m.Bounds()
	 358  		c := color.RGBA{11, 0, 0, 255}
	 359  		src := &image.Uniform{C: c}
	 360  		check := func(desc string) {
	 361  			for y := b.Min.Y; y < b.Max.Y; y++ {
	 362  				for x := b.Min.X; x < b.Max.X; x++ {
	 363  					if !eq(c, m.At(x, y)) {
	 364  						t.Errorf("%s fill: at (%d, %d), sub-image bounds=%v: want %v got %v", desc, x, y, r, c, m.At(x, y))
	 365  						return
	 366  					}
	 367  				}
	 368  			}
	 369  		}
	 370  		// Draw 1 pixel at a time.
	 371  		for y := b.Min.Y; y < b.Max.Y; y++ {
	 372  			for x := b.Min.X; x < b.Max.X; x++ {
	 373  				DrawMask(m, image.Rect(x, y, x+1, y+1), src, image.ZP, nil, image.ZP, Src)
	 374  			}
	 375  		}
	 376  		check("pixel")
	 377  		// Draw 1 row at a time.
	 378  		c = color.RGBA{0, 22, 0, 255}
	 379  		src = &image.Uniform{C: c}
	 380  		for y := b.Min.Y; y < b.Max.Y; y++ {
	 381  			DrawMask(m, image.Rect(b.Min.X, y, b.Max.X, y+1), src, image.ZP, nil, image.ZP, Src)
	 382  		}
	 383  		check("row")
	 384  		// Draw 1 column at a time.
	 385  		c = color.RGBA{0, 0, 33, 255}
	 386  		src = &image.Uniform{C: c}
	 387  		for x := b.Min.X; x < b.Max.X; x++ {
	 388  			DrawMask(m, image.Rect(x, b.Min.Y, x+1, b.Max.Y), src, image.ZP, nil, image.ZP, Src)
	 389  		}
	 390  		check("column")
	 391  		// Draw the whole image at once.
	 392  		c = color.RGBA{44, 55, 66, 77}
	 393  		src = &image.Uniform{C: c}
	 394  		DrawMask(m, b, src, image.ZP, nil, image.ZP, Src)
	 395  		check("whole")
	 396  	}
	 397  }
	 398  
	 399  // TestFloydSteinbergCheckerboard tests that the result of Floyd-Steinberg
	 400  // error diffusion of a uniform 50% gray source image with a black-and-white
	 401  // palette is a checkerboard pattern.
	 402  func TestFloydSteinbergCheckerboard(t *testing.T) {
	 403  	b := image.Rect(0, 0, 640, 480)
	 404  	// We can't represent 50% exactly, but 0x7fff / 0xffff is close enough.
	 405  	src := &image.Uniform{color.Gray16{0x7fff}}
	 406  	dst := image.NewPaletted(b, color.Palette{color.Black, color.White})
	 407  	FloydSteinberg.Draw(dst, b, src, image.Point{})
	 408  	nErr := 0
	 409  	for y := b.Min.Y; y < b.Max.Y; y++ {
	 410  		for x := b.Min.X; x < b.Max.X; x++ {
	 411  			got := dst.Pix[dst.PixOffset(x, y)]
	 412  			want := uint8(x+y) % 2
	 413  			if got != want {
	 414  				t.Errorf("at (%d, %d): got %d, want %d", x, y, got, want)
	 415  				if nErr++; nErr == 10 {
	 416  					t.Fatal("there may be more errors")
	 417  				}
	 418  			}
	 419  		}
	 420  	}
	 421  }
	 422  
	 423  // embeddedPaletted is an Image that behaves like an *image.Paletted but whose
	 424  // type is not *image.Paletted.
	 425  type embeddedPaletted struct {
	 426  	*image.Paletted
	 427  }
	 428  
	 429  // TestPaletted tests that the drawPaletted function behaves the same
	 430  // regardless of whether dst is an *image.Paletted.
	 431  func TestPaletted(t *testing.T) {
	 432  	f, err := os.Open("../testdata/video-001.png")
	 433  	if err != nil {
	 434  		t.Fatalf("open: %v", err)
	 435  	}
	 436  	defer f.Close()
	 437  	video001, err := png.Decode(f)
	 438  	if err != nil {
	 439  		t.Fatalf("decode: %v", err)
	 440  	}
	 441  	b := video001.Bounds()
	 442  
	 443  	cgaPalette := color.Palette{
	 444  		color.RGBA{0x00, 0x00, 0x00, 0xff},
	 445  		color.RGBA{0x55, 0xff, 0xff, 0xff},
	 446  		color.RGBA{0xff, 0x55, 0xff, 0xff},
	 447  		color.RGBA{0xff, 0xff, 0xff, 0xff},
	 448  	}
	 449  	drawers := map[string]Drawer{
	 450  		"src":						 Src,
	 451  		"floyd-steinberg": FloydSteinberg,
	 452  	}
	 453  	sources := map[string]image.Image{
	 454  		"uniform":	&image.Uniform{color.RGBA{0xff, 0x7f, 0xff, 0xff}},
	 455  		"video001": video001,
	 456  	}
	 457  
	 458  	for dName, d := range drawers {
	 459  	loop:
	 460  		for sName, src := range sources {
	 461  			dst0 := image.NewPaletted(b, cgaPalette)
	 462  			dst1 := image.NewPaletted(b, cgaPalette)
	 463  			d.Draw(dst0, b, src, image.Point{})
	 464  			d.Draw(embeddedPaletted{dst1}, b, src, image.Point{})
	 465  			for y := b.Min.Y; y < b.Max.Y; y++ {
	 466  				for x := b.Min.X; x < b.Max.X; x++ {
	 467  					if !eq(dst0.At(x, y), dst1.At(x, y)) {
	 468  						t.Errorf("%s / %s: at (%d, %d), %v versus %v",
	 469  							dName, sName, x, y, dst0.At(x, y), dst1.At(x, y))
	 470  						continue loop
	 471  					}
	 472  				}
	 473  			}
	 474  		}
	 475  	}
	 476  }
	 477  
	 478  func TestSqDiff(t *testing.T) {
	 479  	// This test is similar to the one from the image/color package, but
	 480  	// sqDiff in this package accepts int32 instead of uint32, so test it
	 481  	// for appropriate input.
	 482  
	 483  	// canonical sqDiff implementation
	 484  	orig := func(x, y int32) uint32 {
	 485  		var d uint32
	 486  		if x > y {
	 487  			d = uint32(x - y)
	 488  		} else {
	 489  			d = uint32(y - x)
	 490  		}
	 491  		return (d * d) >> 2
	 492  	}
	 493  	testCases := []int32{
	 494  		0,
	 495  		1,
	 496  		2,
	 497  		0x0fffd,
	 498  		0x0fffe,
	 499  		0x0ffff,
	 500  		0x10000,
	 501  		0x10001,
	 502  		0x10002,
	 503  		0x7ffffffd,
	 504  		0x7ffffffe,
	 505  		0x7fffffff,
	 506  		-0x7ffffffd,
	 507  		-0x7ffffffe,
	 508  		-0x80000000,
	 509  	}
	 510  	for _, x := range testCases {
	 511  		for _, y := range testCases {
	 512  			if got, want := sqDiff(x, y), orig(x, y); got != want {
	 513  				t.Fatalf("sqDiff(%#x, %#x): got %d, want %d", x, y, got, want)
	 514  			}
	 515  		}
	 516  	}
	 517  	if err := quick.CheckEqual(orig, sqDiff, &quick.Config{MaxCountScale: 10}); err != nil {
	 518  		t.Fatal(err)
	 519  	}
	 520  }
	 521  

View as plain text