ycbcr_test.go

Documentation: image/color

		 1  // Copyright 2011 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 color
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"testing"
		10  )
		11  
		12  func delta(x, y uint8) uint8 {
		13  	if x >= y {
		14  		return x - y
		15  	}
		16  	return y - x
		17  }
		18  
		19  func eq(c0, c1 Color) error {
		20  	r0, g0, b0, a0 := c0.RGBA()
		21  	r1, g1, b1, a1 := c1.RGBA()
		22  	if r0 != r1 || g0 != g1 || b0 != b1 || a0 != a1 {
		23  		return fmt.Errorf("got	0x%04x 0x%04x 0x%04x 0x%04x\nwant 0x%04x 0x%04x 0x%04x 0x%04x",
		24  			r0, g0, b0, a0, r1, g1, b1, a1)
		25  	}
		26  	return nil
		27  }
		28  
		29  // TestYCbCrRoundtrip tests that a subset of RGB space can be converted to YCbCr
		30  // and back to within 2/256 tolerance.
		31  func TestYCbCrRoundtrip(t *testing.T) {
		32  	for r := 0; r < 256; r += 7 {
		33  		for g := 0; g < 256; g += 5 {
		34  			for b := 0; b < 256; b += 3 {
		35  				r0, g0, b0 := uint8(r), uint8(g), uint8(b)
		36  				y, cb, cr := RGBToYCbCr(r0, g0, b0)
		37  				r1, g1, b1 := YCbCrToRGB(y, cb, cr)
		38  				if delta(r0, r1) > 2 || delta(g0, g1) > 2 || delta(b0, b1) > 2 {
		39  					t.Fatalf("\nr0, g0, b0 = %d, %d, %d\ny,	cb, cr = %d, %d, %d\nr1, g1, b1 = %d, %d, %d",
		40  						r0, g0, b0, y, cb, cr, r1, g1, b1)
		41  				}
		42  			}
		43  		}
		44  	}
		45  }
		46  
		47  // TestYCbCrToRGBConsistency tests that calling the RGBA method (16 bit color)
		48  // then truncating to 8 bits is equivalent to calling the YCbCrToRGB function (8
		49  // bit color).
		50  func TestYCbCrToRGBConsistency(t *testing.T) {
		51  	for y := 0; y < 256; y += 7 {
		52  		for cb := 0; cb < 256; cb += 5 {
		53  			for cr := 0; cr < 256; cr += 3 {
		54  				x := YCbCr{uint8(y), uint8(cb), uint8(cr)}
		55  				r0, g0, b0, _ := x.RGBA()
		56  				r1, g1, b1 := uint8(r0>>8), uint8(g0>>8), uint8(b0>>8)
		57  				r2, g2, b2 := YCbCrToRGB(x.Y, x.Cb, x.Cr)
		58  				if r1 != r2 || g1 != g2 || b1 != b2 {
		59  					t.Fatalf("y, cb, cr = %d, %d, %d\nr1, g1, b1 = %d, %d, %d\nr2, g2, b2 = %d, %d, %d",
		60  						y, cb, cr, r1, g1, b1, r2, g2, b2)
		61  				}
		62  			}
		63  		}
		64  	}
		65  }
		66  
		67  // TestYCbCrGray tests that YCbCr colors are a superset of Gray colors.
		68  func TestYCbCrGray(t *testing.T) {
		69  	for i := 0; i < 256; i++ {
		70  		c0 := YCbCr{uint8(i), 0x80, 0x80}
		71  		c1 := Gray{uint8(i)}
		72  		if err := eq(c0, c1); err != nil {
		73  			t.Errorf("i=0x%02x:\n%v", i, err)
		74  		}
		75  	}
		76  }
		77  
		78  // TestNYCbCrAAlpha tests that NYCbCrA colors are a superset of Alpha colors.
		79  func TestNYCbCrAAlpha(t *testing.T) {
		80  	for i := 0; i < 256; i++ {
		81  		c0 := NYCbCrA{YCbCr{0xff, 0x80, 0x80}, uint8(i)}
		82  		c1 := Alpha{uint8(i)}
		83  		if err := eq(c0, c1); err != nil {
		84  			t.Errorf("i=0x%02x:\n%v", i, err)
		85  		}
		86  	}
		87  }
		88  
		89  // TestNYCbCrAYCbCr tests that NYCbCrA colors are a superset of YCbCr colors.
		90  func TestNYCbCrAYCbCr(t *testing.T) {
		91  	for i := 0; i < 256; i++ {
		92  		c0 := NYCbCrA{YCbCr{uint8(i), 0x40, 0xc0}, 0xff}
		93  		c1 := YCbCr{uint8(i), 0x40, 0xc0}
		94  		if err := eq(c0, c1); err != nil {
		95  			t.Errorf("i=0x%02x:\n%v", i, err)
		96  		}
		97  	}
		98  }
		99  
	 100  // TestCMYKRoundtrip tests that a subset of RGB space can be converted to CMYK
	 101  // and back to within 1/256 tolerance.
	 102  func TestCMYKRoundtrip(t *testing.T) {
	 103  	for r := 0; r < 256; r += 7 {
	 104  		for g := 0; g < 256; g += 5 {
	 105  			for b := 0; b < 256; b += 3 {
	 106  				r0, g0, b0 := uint8(r), uint8(g), uint8(b)
	 107  				c, m, y, k := RGBToCMYK(r0, g0, b0)
	 108  				r1, g1, b1 := CMYKToRGB(c, m, y, k)
	 109  				if delta(r0, r1) > 1 || delta(g0, g1) > 1 || delta(b0, b1) > 1 {
	 110  					t.Fatalf("\nr0, g0, b0 = %d, %d, %d\nc, m, y, k = %d, %d, %d, %d\nr1, g1, b1 = %d, %d, %d",
	 111  						r0, g0, b0, c, m, y, k, r1, g1, b1)
	 112  				}
	 113  			}
	 114  		}
	 115  	}
	 116  }
	 117  
	 118  // TestCMYKToRGBConsistency tests that calling the RGBA method (16 bit color)
	 119  // then truncating to 8 bits is equivalent to calling the CMYKToRGB function (8
	 120  // bit color).
	 121  func TestCMYKToRGBConsistency(t *testing.T) {
	 122  	for c := 0; c < 256; c += 7 {
	 123  		for m := 0; m < 256; m += 5 {
	 124  			for y := 0; y < 256; y += 3 {
	 125  				for k := 0; k < 256; k += 11 {
	 126  					x := CMYK{uint8(c), uint8(m), uint8(y), uint8(k)}
	 127  					r0, g0, b0, _ := x.RGBA()
	 128  					r1, g1, b1 := uint8(r0>>8), uint8(g0>>8), uint8(b0>>8)
	 129  					r2, g2, b2 := CMYKToRGB(x.C, x.M, x.Y, x.K)
	 130  					if r1 != r2 || g1 != g2 || b1 != b2 {
	 131  						t.Fatalf("c, m, y, k = %d, %d, %d, %d\nr1, g1, b1 = %d, %d, %d\nr2, g2, b2 = %d, %d, %d",
	 132  							c, m, y, k, r1, g1, b1, r2, g2, b2)
	 133  					}
	 134  				}
	 135  			}
	 136  		}
	 137  	}
	 138  }
	 139  
	 140  // TestCMYKGray tests that CMYK colors are a superset of Gray colors.
	 141  func TestCMYKGray(t *testing.T) {
	 142  	for i := 0; i < 256; i++ {
	 143  		if err := eq(CMYK{0x00, 0x00, 0x00, uint8(255 - i)}, Gray{uint8(i)}); err != nil {
	 144  			t.Errorf("i=0x%02x:\n%v", i, err)
	 145  		}
	 146  	}
	 147  }
	 148  
	 149  func TestPalette(t *testing.T) {
	 150  	p := Palette{
	 151  		RGBA{0xff, 0xff, 0xff, 0xff},
	 152  		RGBA{0x80, 0x00, 0x00, 0xff},
	 153  		RGBA{0x7f, 0x00, 0x00, 0x7f},
	 154  		RGBA{0x00, 0x00, 0x00, 0x7f},
	 155  		RGBA{0x00, 0x00, 0x00, 0x00},
	 156  		RGBA{0x40, 0x40, 0x40, 0x40},
	 157  	}
	 158  	// Check that, for a Palette with no repeated colors, the closest color to
	 159  	// each element is itself.
	 160  	for i, c := range p {
	 161  		j := p.Index(c)
	 162  		if i != j {
	 163  			t.Errorf("Index(%v): got %d (color = %v), want %d", c, j, p[j], i)
	 164  		}
	 165  	}
	 166  	// Check that finding the closest color considers alpha, not just red,
	 167  	// green and blue.
	 168  	got := p.Convert(RGBA{0x80, 0x00, 0x00, 0x80})
	 169  	want := RGBA{0x7f, 0x00, 0x00, 0x7f}
	 170  	if got != want {
	 171  		t.Errorf("got %v, want %v", got, want)
	 172  	}
	 173  }
	 174  
	 175  var sink8 uint8
	 176  var sink32 uint32
	 177  
	 178  func BenchmarkYCbCrToRGB(b *testing.B) {
	 179  	// YCbCrToRGB does saturating arithmetic.
	 180  	// Low, middle, and high values can take
	 181  	// different paths through the generated code.
	 182  	b.Run("0", func(b *testing.B) {
	 183  		for i := 0; i < b.N; i++ {
	 184  			sink8, sink8, sink8 = YCbCrToRGB(0, 0, 0)
	 185  		}
	 186  	})
	 187  	b.Run("128", func(b *testing.B) {
	 188  		for i := 0; i < b.N; i++ {
	 189  			sink8, sink8, sink8 = YCbCrToRGB(128, 128, 128)
	 190  		}
	 191  	})
	 192  	b.Run("255", func(b *testing.B) {
	 193  		for i := 0; i < b.N; i++ {
	 194  			sink8, sink8, sink8 = YCbCrToRGB(255, 255, 255)
	 195  		}
	 196  	})
	 197  }
	 198  
	 199  func BenchmarkRGBToYCbCr(b *testing.B) {
	 200  	// RGBToYCbCr does saturating arithmetic.
	 201  	// Different values can take different paths
	 202  	// through the generated code.
	 203  	b.Run("0", func(b *testing.B) {
	 204  		for i := 0; i < b.N; i++ {
	 205  			sink8, sink8, sink8 = RGBToYCbCr(0, 0, 0)
	 206  		}
	 207  	})
	 208  	b.Run("Cb", func(b *testing.B) {
	 209  		for i := 0; i < b.N; i++ {
	 210  			sink8, sink8, sink8 = RGBToYCbCr(0, 0, 255)
	 211  		}
	 212  	})
	 213  	b.Run("Cr", func(b *testing.B) {
	 214  		for i := 0; i < b.N; i++ {
	 215  			sink8, sink8, sink8 = RGBToYCbCr(255, 0, 0)
	 216  		}
	 217  	})
	 218  }
	 219  
	 220  func BenchmarkYCbCrToRGBA(b *testing.B) {
	 221  	// RGB does saturating arithmetic.
	 222  	// Low, middle, and high values can take
	 223  	// different paths through the generated code.
	 224  	b.Run("0", func(b *testing.B) {
	 225  		c := YCbCr{0, 0, 0}
	 226  		for i := 0; i < b.N; i++ {
	 227  			sink32, sink32, sink32, sink32 = c.RGBA()
	 228  		}
	 229  	})
	 230  	b.Run("128", func(b *testing.B) {
	 231  		c := YCbCr{128, 128, 128}
	 232  		for i := 0; i < b.N; i++ {
	 233  			sink32, sink32, sink32, sink32 = c.RGBA()
	 234  		}
	 235  	})
	 236  	b.Run("255", func(b *testing.B) {
	 237  		c := YCbCr{255, 255, 255}
	 238  		for i := 0; i < b.N; i++ {
	 239  			sink32, sink32, sink32, sink32 = c.RGBA()
	 240  		}
	 241  	})
	 242  }
	 243  
	 244  func BenchmarkNYCbCrAToRGBA(b *testing.B) {
	 245  	// RGBA does saturating arithmetic.
	 246  	// Low, middle, and high values can take
	 247  	// different paths through the generated code.
	 248  	b.Run("0", func(b *testing.B) {
	 249  		c := NYCbCrA{YCbCr{0, 0, 0}, 0xff}
	 250  		for i := 0; i < b.N; i++ {
	 251  			sink32, sink32, sink32, sink32 = c.RGBA()
	 252  		}
	 253  	})
	 254  	b.Run("128", func(b *testing.B) {
	 255  		c := NYCbCrA{YCbCr{128, 128, 128}, 0xff}
	 256  		for i := 0; i < b.N; i++ {
	 257  			sink32, sink32, sink32, sink32 = c.RGBA()
	 258  		}
	 259  	})
	 260  	b.Run("255", func(b *testing.B) {
	 261  		c := NYCbCrA{YCbCr{255, 255, 255}, 0xff}
	 262  		for i := 0; i < b.N; i++ {
	 263  			sink32, sink32, sink32, sink32 = c.RGBA()
	 264  		}
	 265  	})
	 266  }
	 267
View as plain text