diff options
Diffstat (limited to 'src/pkg/image/image.go')
| -rw-r--r-- | src/pkg/image/image.go | 904 |
1 files changed, 0 insertions, 904 deletions
diff --git a/src/pkg/image/image.go b/src/pkg/image/image.go deleted file mode 100644 index 32a89ef34..000000000 --- a/src/pkg/image/image.go +++ /dev/null @@ -1,904 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package image implements a basic 2-D image library. -// -// The fundamental interface is called Image. An Image contains colors, which -// are described in the image/color package. -// -// Values of the Image interface are created either by calling functions such -// as NewRGBA and NewPaletted, or by calling Decode on an io.Reader containing -// image data in a format such as GIF, JPEG or PNG. Decoding any particular -// image format requires the prior registration of a decoder function. -// Registration is typically automatic as a side effect of initializing that -// format's package so that, to decode a PNG image, it suffices to have -// import _ "image/png" -// in a program's main package. The _ means to import a package purely for its -// initialization side effects. -// -// See "The Go image package" for more details: -// http://golang.org/doc/articles/image_package.html -package image - -import ( - "image/color" -) - -// Config holds an image's color model and dimensions. -type Config struct { - ColorModel color.Model - Width, Height int -} - -// Image is a finite rectangular grid of color.Color values taken from a color -// model. -type Image interface { - // ColorModel returns the Image's color model. - ColorModel() color.Model - // Bounds returns the domain for which At can return non-zero color. - // The bounds do not necessarily contain the point (0, 0). - Bounds() Rectangle - // At returns the color of the pixel at (x, y). - // At(Bounds().Min.X, Bounds().Min.Y) returns the upper-left pixel of the grid. - // At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one. - At(x, y int) color.Color -} - -// PalettedImage is an image whose colors may come from a limited palette. -// If m is a PalettedImage and m.ColorModel() returns a PalettedColorModel p, -// then m.At(x, y) should be equivalent to p[m.ColorIndexAt(x, y)]. If m's -// color model is not a PalettedColorModel, then ColorIndexAt's behavior is -// undefined. -type PalettedImage interface { - // ColorIndexAt returns the palette index of the pixel at (x, y). - ColorIndexAt(x, y int) uint8 - Image -} - -// RGBA is an in-memory image whose At method returns color.RGBA values. -type RGBA struct { - // Pix holds the image's pixels, in R, G, B, A order. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *RGBA) ColorModel() color.Model { return color.RGBAModel } - -func (p *RGBA) Bounds() Rectangle { return p.Rect } - -func (p *RGBA) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.RGBA{} - } - i := p.PixOffset(x, y) - return color.RGBA{p.Pix[i+0], p.Pix[i+1], p.Pix[i+2], p.Pix[i+3]} -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *RGBA) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*4 -} - -func (p *RGBA) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - c1 := color.RGBAModel.Convert(c).(color.RGBA) - p.Pix[i+0] = c1.R - p.Pix[i+1] = c1.G - p.Pix[i+2] = c1.B - p.Pix[i+3] = c1.A -} - -func (p *RGBA) SetRGBA(x, y int, c color.RGBA) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i+0] = c.R - p.Pix[i+1] = c.G - p.Pix[i+2] = c.B - p.Pix[i+3] = c.A -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *RGBA) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &RGBA{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &RGBA{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *RGBA) Opaque() bool { - if p.Rect.Empty() { - return true - } - i0, i1 := 3, p.Rect.Dx()*4 - for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { - for i := i0; i < i1; i += 4 { - if p.Pix[i] != 0xff { - return false - } - } - i0 += p.Stride - i1 += p.Stride - } - return true -} - -// NewRGBA returns a new RGBA with the given bounds. -func NewRGBA(r Rectangle) *RGBA { - w, h := r.Dx(), r.Dy() - buf := make([]uint8, 4*w*h) - return &RGBA{buf, 4 * w, r} -} - -// RGBA64 is an in-memory image whose At method returns color.RGBA64 values. -type RGBA64 struct { - // Pix holds the image's pixels, in R, G, B, A order and big-endian format. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*8]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *RGBA64) ColorModel() color.Model { return color.RGBA64Model } - -func (p *RGBA64) Bounds() Rectangle { return p.Rect } - -func (p *RGBA64) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.RGBA64{} - } - i := p.PixOffset(x, y) - return color.RGBA64{ - uint16(p.Pix[i+0])<<8 | uint16(p.Pix[i+1]), - uint16(p.Pix[i+2])<<8 | uint16(p.Pix[i+3]), - uint16(p.Pix[i+4])<<8 | uint16(p.Pix[i+5]), - uint16(p.Pix[i+6])<<8 | uint16(p.Pix[i+7]), - } -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *RGBA64) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*8 -} - -func (p *RGBA64) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - c1 := color.RGBA64Model.Convert(c).(color.RGBA64) - p.Pix[i+0] = uint8(c1.R >> 8) - p.Pix[i+1] = uint8(c1.R) - p.Pix[i+2] = uint8(c1.G >> 8) - p.Pix[i+3] = uint8(c1.G) - p.Pix[i+4] = uint8(c1.B >> 8) - p.Pix[i+5] = uint8(c1.B) - p.Pix[i+6] = uint8(c1.A >> 8) - p.Pix[i+7] = uint8(c1.A) -} - -func (p *RGBA64) SetRGBA64(x, y int, c color.RGBA64) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i+0] = uint8(c.R >> 8) - p.Pix[i+1] = uint8(c.R) - p.Pix[i+2] = uint8(c.G >> 8) - p.Pix[i+3] = uint8(c.G) - p.Pix[i+4] = uint8(c.B >> 8) - p.Pix[i+5] = uint8(c.B) - p.Pix[i+6] = uint8(c.A >> 8) - p.Pix[i+7] = uint8(c.A) -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *RGBA64) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &RGBA64{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &RGBA64{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *RGBA64) Opaque() bool { - if p.Rect.Empty() { - return true - } - i0, i1 := 6, p.Rect.Dx()*8 - for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { - for i := i0; i < i1; i += 8 { - if p.Pix[i+0] != 0xff || p.Pix[i+1] != 0xff { - return false - } - } - i0 += p.Stride - i1 += p.Stride - } - return true -} - -// NewRGBA64 returns a new RGBA64 with the given bounds. -func NewRGBA64(r Rectangle) *RGBA64 { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 8*w*h) - return &RGBA64{pix, 8 * w, r} -} - -// NRGBA is an in-memory image whose At method returns color.NRGBA values. -type NRGBA struct { - // Pix holds the image's pixels, in R, G, B, A order. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *NRGBA) ColorModel() color.Model { return color.NRGBAModel } - -func (p *NRGBA) Bounds() Rectangle { return p.Rect } - -func (p *NRGBA) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.NRGBA{} - } - i := p.PixOffset(x, y) - return color.NRGBA{p.Pix[i+0], p.Pix[i+1], p.Pix[i+2], p.Pix[i+3]} -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *NRGBA) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*4 -} - -func (p *NRGBA) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - c1 := color.NRGBAModel.Convert(c).(color.NRGBA) - p.Pix[i+0] = c1.R - p.Pix[i+1] = c1.G - p.Pix[i+2] = c1.B - p.Pix[i+3] = c1.A -} - -func (p *NRGBA) SetNRGBA(x, y int, c color.NRGBA) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i+0] = c.R - p.Pix[i+1] = c.G - p.Pix[i+2] = c.B - p.Pix[i+3] = c.A -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *NRGBA) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &NRGBA{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &NRGBA{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *NRGBA) Opaque() bool { - if p.Rect.Empty() { - return true - } - i0, i1 := 3, p.Rect.Dx()*4 - for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { - for i := i0; i < i1; i += 4 { - if p.Pix[i] != 0xff { - return false - } - } - i0 += p.Stride - i1 += p.Stride - } - return true -} - -// NewNRGBA returns a new NRGBA with the given bounds. -func NewNRGBA(r Rectangle) *NRGBA { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 4*w*h) - return &NRGBA{pix, 4 * w, r} -} - -// NRGBA64 is an in-memory image whose At method returns color.NRGBA64 values. -type NRGBA64 struct { - // Pix holds the image's pixels, in R, G, B, A order and big-endian format. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*8]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *NRGBA64) ColorModel() color.Model { return color.NRGBA64Model } - -func (p *NRGBA64) Bounds() Rectangle { return p.Rect } - -func (p *NRGBA64) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.NRGBA64{} - } - i := p.PixOffset(x, y) - return color.NRGBA64{ - uint16(p.Pix[i+0])<<8 | uint16(p.Pix[i+1]), - uint16(p.Pix[i+2])<<8 | uint16(p.Pix[i+3]), - uint16(p.Pix[i+4])<<8 | uint16(p.Pix[i+5]), - uint16(p.Pix[i+6])<<8 | uint16(p.Pix[i+7]), - } -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *NRGBA64) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*8 -} - -func (p *NRGBA64) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - c1 := color.NRGBA64Model.Convert(c).(color.NRGBA64) - p.Pix[i+0] = uint8(c1.R >> 8) - p.Pix[i+1] = uint8(c1.R) - p.Pix[i+2] = uint8(c1.G >> 8) - p.Pix[i+3] = uint8(c1.G) - p.Pix[i+4] = uint8(c1.B >> 8) - p.Pix[i+5] = uint8(c1.B) - p.Pix[i+6] = uint8(c1.A >> 8) - p.Pix[i+7] = uint8(c1.A) -} - -func (p *NRGBA64) SetNRGBA64(x, y int, c color.NRGBA64) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i+0] = uint8(c.R >> 8) - p.Pix[i+1] = uint8(c.R) - p.Pix[i+2] = uint8(c.G >> 8) - p.Pix[i+3] = uint8(c.G) - p.Pix[i+4] = uint8(c.B >> 8) - p.Pix[i+5] = uint8(c.B) - p.Pix[i+6] = uint8(c.A >> 8) - p.Pix[i+7] = uint8(c.A) -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *NRGBA64) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &NRGBA64{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &NRGBA64{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *NRGBA64) Opaque() bool { - if p.Rect.Empty() { - return true - } - i0, i1 := 6, p.Rect.Dx()*8 - for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { - for i := i0; i < i1; i += 8 { - if p.Pix[i+0] != 0xff || p.Pix[i+1] != 0xff { - return false - } - } - i0 += p.Stride - i1 += p.Stride - } - return true -} - -// NewNRGBA64 returns a new NRGBA64 with the given bounds. -func NewNRGBA64(r Rectangle) *NRGBA64 { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 8*w*h) - return &NRGBA64{pix, 8 * w, r} -} - -// Alpha is an in-memory image whose At method returns color.Alpha values. -type Alpha struct { - // Pix holds the image's pixels, as alpha values. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *Alpha) ColorModel() color.Model { return color.AlphaModel } - -func (p *Alpha) Bounds() Rectangle { return p.Rect } - -func (p *Alpha) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.Alpha{} - } - i := p.PixOffset(x, y) - return color.Alpha{p.Pix[i]} -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *Alpha) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*1 -} - -func (p *Alpha) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i] = color.AlphaModel.Convert(c).(color.Alpha).A -} - -func (p *Alpha) SetAlpha(x, y int, c color.Alpha) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i] = c.A -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *Alpha) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &Alpha{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &Alpha{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *Alpha) Opaque() bool { - if p.Rect.Empty() { - return true - } - i0, i1 := 0, p.Rect.Dx() - for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { - for i := i0; i < i1; i++ { - if p.Pix[i] != 0xff { - return false - } - } - i0 += p.Stride - i1 += p.Stride - } - return true -} - -// NewAlpha returns a new Alpha with the given bounds. -func NewAlpha(r Rectangle) *Alpha { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 1*w*h) - return &Alpha{pix, 1 * w, r} -} - -// Alpha16 is an in-memory image whose At method returns color.Alpha64 values. -type Alpha16 struct { - // Pix holds the image's pixels, as alpha values in big-endian format. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*2]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *Alpha16) ColorModel() color.Model { return color.Alpha16Model } - -func (p *Alpha16) Bounds() Rectangle { return p.Rect } - -func (p *Alpha16) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.Alpha16{} - } - i := p.PixOffset(x, y) - return color.Alpha16{uint16(p.Pix[i+0])<<8 | uint16(p.Pix[i+1])} -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *Alpha16) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*2 -} - -func (p *Alpha16) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - c1 := color.Alpha16Model.Convert(c).(color.Alpha16) - p.Pix[i+0] = uint8(c1.A >> 8) - p.Pix[i+1] = uint8(c1.A) -} - -func (p *Alpha16) SetAlpha16(x, y int, c color.Alpha16) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i+0] = uint8(c.A >> 8) - p.Pix[i+1] = uint8(c.A) -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *Alpha16) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &Alpha16{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &Alpha16{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *Alpha16) Opaque() bool { - if p.Rect.Empty() { - return true - } - i0, i1 := 0, p.Rect.Dx()*2 - for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { - for i := i0; i < i1; i += 2 { - if p.Pix[i+0] != 0xff || p.Pix[i+1] != 0xff { - return false - } - } - i0 += p.Stride - i1 += p.Stride - } - return true -} - -// NewAlpha16 returns a new Alpha16 with the given bounds. -func NewAlpha16(r Rectangle) *Alpha16 { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 2*w*h) - return &Alpha16{pix, 2 * w, r} -} - -// Gray is an in-memory image whose At method returns color.Gray values. -type Gray struct { - // Pix holds the image's pixels, as gray values. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *Gray) ColorModel() color.Model { return color.GrayModel } - -func (p *Gray) Bounds() Rectangle { return p.Rect } - -func (p *Gray) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.Gray{} - } - i := p.PixOffset(x, y) - return color.Gray{p.Pix[i]} -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *Gray) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*1 -} - -func (p *Gray) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i] = color.GrayModel.Convert(c).(color.Gray).Y -} - -func (p *Gray) SetGray(x, y int, c color.Gray) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i] = c.Y -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *Gray) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &Gray{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &Gray{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *Gray) Opaque() bool { - return true -} - -// NewGray returns a new Gray with the given bounds. -func NewGray(r Rectangle) *Gray { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 1*w*h) - return &Gray{pix, 1 * w, r} -} - -// Gray16 is an in-memory image whose At method returns color.Gray16 values. -type Gray16 struct { - // Pix holds the image's pixels, as gray values in big-endian format. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*2]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle -} - -func (p *Gray16) ColorModel() color.Model { return color.Gray16Model } - -func (p *Gray16) Bounds() Rectangle { return p.Rect } - -func (p *Gray16) At(x, y int) color.Color { - if !(Point{x, y}.In(p.Rect)) { - return color.Gray16{} - } - i := p.PixOffset(x, y) - return color.Gray16{uint16(p.Pix[i+0])<<8 | uint16(p.Pix[i+1])} -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *Gray16) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*2 -} - -func (p *Gray16) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - c1 := color.Gray16Model.Convert(c).(color.Gray16) - p.Pix[i+0] = uint8(c1.Y >> 8) - p.Pix[i+1] = uint8(c1.Y) -} - -func (p *Gray16) SetGray16(x, y int, c color.Gray16) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i+0] = uint8(c.Y >> 8) - p.Pix[i+1] = uint8(c.Y) -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *Gray16) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &Gray16{} - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &Gray16{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: r, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *Gray16) Opaque() bool { - return true -} - -// NewGray16 returns a new Gray16 with the given bounds. -func NewGray16(r Rectangle) *Gray16 { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 2*w*h) - return &Gray16{pix, 2 * w, r} -} - -// Paletted is an in-memory image of uint8 indices into a given palette. -type Paletted struct { - // Pix holds the image's pixels, as palette indices. The pixel at - // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1]. - Pix []uint8 - // Stride is the Pix stride (in bytes) between vertically adjacent pixels. - Stride int - // Rect is the image's bounds. - Rect Rectangle - // Palette is the image's palette. - Palette color.Palette -} - -func (p *Paletted) ColorModel() color.Model { return p.Palette } - -func (p *Paletted) Bounds() Rectangle { return p.Rect } - -func (p *Paletted) At(x, y int) color.Color { - if len(p.Palette) == 0 { - return nil - } - if !(Point{x, y}.In(p.Rect)) { - return p.Palette[0] - } - i := p.PixOffset(x, y) - return p.Palette[p.Pix[i]] -} - -// PixOffset returns the index of the first element of Pix that corresponds to -// the pixel at (x, y). -func (p *Paletted) PixOffset(x, y int) int { - return (y-p.Rect.Min.Y)*p.Stride + (x-p.Rect.Min.X)*1 -} - -func (p *Paletted) Set(x, y int, c color.Color) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i] = uint8(p.Palette.Index(c)) -} - -func (p *Paletted) ColorIndexAt(x, y int) uint8 { - if !(Point{x, y}.In(p.Rect)) { - return 0 - } - i := p.PixOffset(x, y) - return p.Pix[i] -} - -func (p *Paletted) SetColorIndex(x, y int, index uint8) { - if !(Point{x, y}.In(p.Rect)) { - return - } - i := p.PixOffset(x, y) - p.Pix[i] = index -} - -// SubImage returns an image representing the portion of the image p visible -// through r. The returned value shares pixels with the original image. -func (p *Paletted) SubImage(r Rectangle) Image { - r = r.Intersect(p.Rect) - // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside - // either r1 or r2 if the intersection is empty. Without explicitly checking for - // this, the Pix[i:] expression below can panic. - if r.Empty() { - return &Paletted{ - Palette: p.Palette, - } - } - i := p.PixOffset(r.Min.X, r.Min.Y) - return &Paletted{ - Pix: p.Pix[i:], - Stride: p.Stride, - Rect: p.Rect.Intersect(r), - Palette: p.Palette, - } -} - -// Opaque scans the entire image and reports whether it is fully opaque. -func (p *Paletted) Opaque() bool { - var present [256]bool - i0, i1 := 0, p.Rect.Dx() - for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ { - for _, c := range p.Pix[i0:i1] { - present[c] = true - } - i0 += p.Stride - i1 += p.Stride - } - for i, c := range p.Palette { - if !present[i] { - continue - } - _, _, _, a := c.RGBA() - if a != 0xffff { - return false - } - } - return true -} - -// NewPaletted returns a new Paletted with the given width, height and palette. -func NewPaletted(r Rectangle, p color.Palette) *Paletted { - w, h := r.Dx(), r.Dy() - pix := make([]uint8, 1*w*h) - return &Paletted{pix, 1 * w, r, p} -} |