2009-08-26 22:51:03 -06:00
|
|
|
// 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.
|
|
|
|
|
2011-04-19 17:57:05 -06:00
|
|
|
// Package image implements a basic 2-D image library.
|
2011-09-22 15:22:28 -06:00
|
|
|
//
|
2012-02-05 17:04:12 -07:00
|
|
|
// 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:
|
2012-03-27 21:20:51 -06:00
|
|
|
// http://golang.org/doc/articles/image_package.html
|
2009-08-26 22:51:03 -06:00
|
|
|
package image
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
import (
|
|
|
|
"image/color"
|
|
|
|
)
|
|
|
|
|
2011-07-12 00:39:38 -06:00
|
|
|
// Config holds an image's color model and dimensions.
|
2010-09-03 02:03:08 -06:00
|
|
|
type Config struct {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
ColorModel color.Model
|
2010-09-03 02:03:08 -06:00
|
|
|
Width, Height int
|
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// Image is a finite rectangular grid of color.Color values taken from a color
|
|
|
|
// model.
|
2009-08-26 22:51:03 -06:00
|
|
|
type Image interface {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
// ColorModel returns the Image's color model.
|
|
|
|
ColorModel() color.Model
|
2010-08-09 20:08:52 -06:00
|
|
|
// 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.
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
At(x, y int) color.Color
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
|
|
|
|
2011-08-30 16:27:00 -06:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// RGBA is an in-memory image whose At method returns color.RGBA values.
|
2009-08-26 22:51:03 -06:00
|
|
|
type RGBA struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA) ColorModel() color.Model { return color.RGBAModel }
|
2009-08-26 22:51:03 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *RGBA) Bounds() Rectangle { return p.Rect }
|
2009-08-26 22:51:03 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.RGBA{}
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.RGBA{p.Pix[i+0], p.Pix[i+1], p.Pix[i+2], p.Pix[i+3]}
|
2010-08-09 20:08:52 -06:00
|
|
|
}
|
2009-08-26 22:51:03 -06:00
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
c1 := color.RGBAModel.Convert(c).(color.RGBA)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = c1.R
|
|
|
|
p.Pix[i+1] = c1.G
|
|
|
|
p.Pix[i+2] = c1.B
|
|
|
|
p.Pix[i+3] = c1.A
|
2010-08-09 20:08:52 -06:00
|
|
|
}
|
2009-08-26 22:51:03 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA) SetRGBA(x, y int, c color.RGBA) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:10:37 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = c.R
|
|
|
|
p.Pix[i+1] = c.G
|
|
|
|
p.Pix[i+2] = c.B
|
|
|
|
p.Pix[i+3] = c.A
|
2011-05-02 16:10:37 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &RGBA{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-06-03 18:18:26 -06:00
|
|
|
func (p *RGBA) Opaque() bool {
|
2010-08-10 00:34:57 -06:00
|
|
|
if p.Rect.Empty() {
|
|
|
|
return true
|
|
|
|
}
|
2011-07-12 00:39:38 -06:00
|
|
|
i0, i1 := 3, p.Rect.Dx()*4
|
2010-08-10 00:34:57 -06:00
|
|
|
for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ {
|
2011-07-12 00:39:38 -06:00
|
|
|
for i := i0; i < i1; i += 4 {
|
|
|
|
if p.Pix[i] != 0xff {
|
2010-08-10 00:34:57 -06:00
|
|
|
return false
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
}
|
2010-08-10 00:34:57 -06:00
|
|
|
i0 += p.Stride
|
|
|
|
i1 += p.Stride
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewRGBA returns a new RGBA with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewRGBA(r Rectangle) *RGBA {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
buf := make([]uint8, 4*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &RGBA{buf, 4 * w, r}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// RGBA64 is an in-memory image whose At method returns color.RGBA64 values.
|
2009-08-26 22:51:03 -06:00
|
|
|
type RGBA64 struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA64) ColorModel() color.Model { return color.RGBA64Model }
|
2009-08-26 22:51:03 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *RGBA64) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA64) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.RGBA64{}
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.RGBA64{
|
2011-07-12 00:39:38 -06:00
|
|
|
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]),
|
|
|
|
}
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA64) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
c1 := color.RGBA64Model.Convert(c).(color.RGBA64)
|
2011-07-12 00:39:38 -06:00
|
|
|
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)
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2009-08-26 22:51:03 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *RGBA64) SetRGBA64(x, y int, c color.RGBA64) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:10:37 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
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)
|
2011-05-02 16:10:37 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &RGBA64{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-06-03 18:18:26 -06:00
|
|
|
func (p *RGBA64) Opaque() bool {
|
2010-08-10 00:34:57 -06:00
|
|
|
if p.Rect.Empty() {
|
|
|
|
return true
|
|
|
|
}
|
2011-07-12 00:39:38 -06:00
|
|
|
i0, i1 := 6, p.Rect.Dx()*8
|
2010-08-10 00:34:57 -06:00
|
|
|
for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ {
|
2011-07-12 00:39:38 -06:00
|
|
|
for i := i0; i < i1; i += 8 {
|
|
|
|
if p.Pix[i+0] != 0xff || p.Pix[i+1] != 0xff {
|
2010-08-10 00:34:57 -06:00
|
|
|
return false
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
}
|
2010-08-10 00:34:57 -06:00
|
|
|
i0 += p.Stride
|
|
|
|
i1 += p.Stride
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewRGBA64 returns a new RGBA64 with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewRGBA64(r Rectangle) *RGBA64 {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 8*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &RGBA64{pix, 8 * w, r}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// NRGBA is an in-memory image whose At method returns color.NRGBA values.
|
2009-09-10 22:33:44 -06:00
|
|
|
type NRGBA struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA) ColorModel() color.Model { return color.NRGBAModel }
|
2009-09-10 22:33:44 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *NRGBA) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.NRGBA{}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.NRGBA{p.Pix[i+0], p.Pix[i+1], p.Pix[i+2], p.Pix[i+3]}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
c1 := color.NRGBAModel.Convert(c).(color.NRGBA)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = c1.R
|
|
|
|
p.Pix[i+1] = c1.G
|
|
|
|
p.Pix[i+2] = c1.B
|
|
|
|
p.Pix[i+3] = c1.A
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2009-09-10 22:33:44 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA) SetNRGBA(x, y int, c color.NRGBA) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:10:37 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = c.R
|
|
|
|
p.Pix[i+1] = c.G
|
|
|
|
p.Pix[i+2] = c.B
|
|
|
|
p.Pix[i+3] = c.A
|
2011-05-02 16:10:37 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &NRGBA{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-06-03 18:18:26 -06:00
|
|
|
func (p *NRGBA) Opaque() bool {
|
2010-08-10 00:34:57 -06:00
|
|
|
if p.Rect.Empty() {
|
|
|
|
return true
|
|
|
|
}
|
2011-07-12 00:39:38 -06:00
|
|
|
i0, i1 := 3, p.Rect.Dx()*4
|
2010-08-10 00:34:57 -06:00
|
|
|
for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ {
|
2011-07-12 00:39:38 -06:00
|
|
|
for i := i0; i < i1; i += 4 {
|
|
|
|
if p.Pix[i] != 0xff {
|
2010-08-10 00:34:57 -06:00
|
|
|
return false
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
}
|
2010-08-10 00:34:57 -06:00
|
|
|
i0 += p.Stride
|
|
|
|
i1 += p.Stride
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewNRGBA returns a new NRGBA with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewNRGBA(r Rectangle) *NRGBA {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 4*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &NRGBA{pix, 4 * w, r}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// NRGBA64 is an in-memory image whose At method returns color.NRGBA64 values.
|
2009-09-10 22:33:44 -06:00
|
|
|
type NRGBA64 struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA64) ColorModel() color.Model { return color.NRGBA64Model }
|
2009-09-10 22:33:44 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *NRGBA64) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA64) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.NRGBA64{}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.NRGBA64{
|
2011-07-12 00:39:38 -06:00
|
|
|
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]),
|
|
|
|
}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA64) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
c1 := color.NRGBA64Model.Convert(c).(color.NRGBA64)
|
2011-07-12 00:39:38 -06:00
|
|
|
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)
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2009-09-10 22:33:44 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *NRGBA64) SetNRGBA64(x, y int, c color.NRGBA64) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:10:37 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
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)
|
2011-05-02 16:10:37 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &NRGBA64{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-06-03 18:18:26 -06:00
|
|
|
func (p *NRGBA64) Opaque() bool {
|
2010-08-10 00:34:57 -06:00
|
|
|
if p.Rect.Empty() {
|
|
|
|
return true
|
|
|
|
}
|
2011-07-12 00:39:38 -06:00
|
|
|
i0, i1 := 6, p.Rect.Dx()*8
|
2010-08-10 00:34:57 -06:00
|
|
|
for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ {
|
2011-07-12 00:39:38 -06:00
|
|
|
for i := i0; i < i1; i += 8 {
|
|
|
|
if p.Pix[i+0] != 0xff || p.Pix[i+1] != 0xff {
|
2010-08-10 00:34:57 -06:00
|
|
|
return false
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
}
|
2010-08-10 00:34:57 -06:00
|
|
|
i0 += p.Stride
|
|
|
|
i1 += p.Stride
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewNRGBA64 returns a new NRGBA64 with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewNRGBA64(r Rectangle) *NRGBA64 {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 8*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &NRGBA64{pix, 8 * w, r}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// Alpha is an in-memory image whose At method returns color.Alpha values.
|
2010-02-02 00:38:04 -07:00
|
|
|
type Alpha struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2010-02-02 00:38:04 -07:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha) ColorModel() color.Model { return color.AlphaModel }
|
2010-02-02 00:38:04 -07:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *Alpha) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Alpha{}
|
2010-02-02 00:38:04 -07:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Alpha{p.Pix[i]}
|
2010-02-02 00:38:04 -07:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:42:46 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
p.Pix[i] = color.AlphaModel.Convert(c).(color.Alpha).A
|
2011-05-02 16:42:46 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha) SetAlpha(x, y int, c color.Alpha) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i] = c.A
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2010-02-02 00:38:04 -07:00
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &Alpha{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-06-03 18:18:26 -06:00
|
|
|
func (p *Alpha) Opaque() bool {
|
2010-08-10 00:34:57 -06:00
|
|
|
if p.Rect.Empty() {
|
|
|
|
return true
|
|
|
|
}
|
2011-07-09 22:29:47 -06:00
|
|
|
i0, i1 := 0, p.Rect.Dx()
|
2010-08-10 00:34:57 -06:00
|
|
|
for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ {
|
2011-07-12 00:39:38 -06:00
|
|
|
for i := i0; i < i1; i++ {
|
|
|
|
if p.Pix[i] != 0xff {
|
2010-08-10 00:34:57 -06:00
|
|
|
return false
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
}
|
2010-08-10 00:34:57 -06:00
|
|
|
i0 += p.Stride
|
|
|
|
i1 += p.Stride
|
2010-06-03 18:18:26 -06:00
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewAlpha returns a new Alpha with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewAlpha(r Rectangle) *Alpha {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 1*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &Alpha{pix, 1 * w, r}
|
2010-02-02 00:38:04 -07:00
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// Alpha16 is an in-memory image whose At method returns color.Alpha64 values.
|
2010-06-15 20:36:07 -06:00
|
|
|
type Alpha16 struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2010-06-15 20:36:07 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha16) ColorModel() color.Model { return color.Alpha16Model }
|
2010-06-15 20:36:07 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *Alpha16) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha16) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Alpha16{}
|
2010-06-15 20:36:07 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Alpha16{uint16(p.Pix[i+0])<<8 | uint16(p.Pix[i+1])}
|
2010-06-15 20:36:07 -06:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha16) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
c1 := color.Alpha16Model.Convert(c).(color.Alpha16)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = uint8(c1.A >> 8)
|
|
|
|
p.Pix[i+1] = uint8(c1.A)
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2010-06-15 20:36:07 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Alpha16) SetAlpha16(x, y int, c color.Alpha16) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:10:37 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = uint8(c.A >> 8)
|
|
|
|
p.Pix[i+1] = uint8(c.A)
|
2011-05-02 16:10:37 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &Alpha16{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-06-15 20:36:07 -06:00
|
|
|
func (p *Alpha16) Opaque() bool {
|
2010-08-10 00:34:57 -06:00
|
|
|
if p.Rect.Empty() {
|
|
|
|
return true
|
|
|
|
}
|
2011-07-12 00:39:38 -06:00
|
|
|
i0, i1 := 0, p.Rect.Dx()*2
|
2010-08-10 00:34:57 -06:00
|
|
|
for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ {
|
2011-07-12 00:39:38 -06:00
|
|
|
for i := i0; i < i1; i += 2 {
|
|
|
|
if p.Pix[i+0] != 0xff || p.Pix[i+1] != 0xff {
|
2010-08-10 00:34:57 -06:00
|
|
|
return false
|
2010-06-15 20:36:07 -06:00
|
|
|
}
|
|
|
|
}
|
2010-08-10 00:34:57 -06:00
|
|
|
i0 += p.Stride
|
|
|
|
i1 += p.Stride
|
2010-06-15 20:36:07 -06:00
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewAlpha16 returns a new Alpha16 with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewAlpha16(r Rectangle) *Alpha16 {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 2*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &Alpha16{pix, 2 * w, r}
|
2010-06-15 20:36:07 -06:00
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// Gray is an in-memory image whose At method returns color.Gray values.
|
2010-08-02 18:57:53 -06:00
|
|
|
type Gray struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray) ColorModel() color.Model { return color.GrayModel }
|
2010-08-02 18:57:53 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *Gray) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Gray{}
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Gray{p.Pix[i]}
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
p.Pix[i] = color.GrayModel.Convert(c).(color.Gray).Y
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2010-08-02 18:57:53 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray) SetGray(x, y int, c color.Gray) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:10:37 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i] = c.Y
|
2011-05-02 16:10:37 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &Gray{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-08-02 18:57:53 -06:00
|
|
|
func (p *Gray) Opaque() bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewGray returns a new Gray with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewGray(r Rectangle) *Gray {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 1*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &Gray{pix, 1 * w, r}
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
|
|
|
|
2012-02-05 17:04:12 -07:00
|
|
|
// Gray16 is an in-memory image whose At method returns color.Gray16 values.
|
2010-08-02 18:57:53 -06:00
|
|
|
type Gray16 struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray16) ColorModel() color.Model { return color.Gray16Model }
|
2010-08-02 18:57:53 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *Gray16) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray16) At(x, y int) color.Color {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Gray16{}
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return color.Gray16{uint16(p.Pix[i+0])<<8 | uint16(p.Pix[i+1])}
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray16) Set(x, y int, c color.Color) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
c1 := color.Gray16Model.Convert(c).(color.Gray16)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = uint8(c1.Y >> 8)
|
|
|
|
p.Pix[i+1] = uint8(c1.Y)
|
2010-08-10 00:34:57 -06:00
|
|
|
}
|
2010-08-02 18:57:53 -06:00
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Gray16) SetGray16(x, y int, c color.Gray16) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2011-05-02 16:10:37 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-12 00:39:38 -06:00
|
|
|
p.Pix[i+0] = uint8(c.Y >> 8)
|
|
|
|
p.Pix[i+1] = uint8(c.Y)
|
2011-05-02 16:10:37 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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{}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &Gray16{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
2011-07-09 22:29:47 -06:00
|
|
|
Rect: r,
|
2011-06-02 02:51:41 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-08-02 18:57:53 -06:00
|
|
|
func (p *Gray16) Opaque() bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2012-01-19 16:44:22 -07:00
|
|
|
// NewGray16 returns a new Gray16 with the given bounds.
|
2011-09-14 05:39:49 -06:00
|
|
|
func NewGray16(r Rectangle) *Gray16 {
|
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 2*w*h)
|
2011-09-14 05:39:49 -06:00
|
|
|
return &Gray16{pix, 2 * w, r}
|
2010-08-02 18:57:53 -06:00
|
|
|
}
|
|
|
|
|
2011-07-12 00:39:38 -06:00
|
|
|
// Paletted is an in-memory image of uint8 indices into a given palette.
|
2009-08-26 22:51:03 -06:00
|
|
|
type Paletted struct {
|
2011-07-12 00:39:38 -06:00
|
|
|
// 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.
|
2010-08-10 00:34:57 -06:00
|
|
|
Stride int
|
|
|
|
// Rect is the image's bounds.
|
|
|
|
Rect Rectangle
|
|
|
|
// Palette is the image's palette.
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
Palette color.Palette
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Paletted) ColorModel() color.Model { return p.Palette }
|
2009-08-26 22:51:03 -06:00
|
|
|
|
2010-08-10 00:34:57 -06:00
|
|
|
func (p *Paletted) Bounds() Rectangle { return p.Rect }
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Paletted) At(x, y int) color.Color {
|
2010-08-10 00:34:57 -06:00
|
|
|
if len(p.Palette) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return p.Palette[0]
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-09 22:29:47 -06:00
|
|
|
return p.Palette[p.Pix[i]]
|
2009-08-26 22:51:03 -06:00
|
|
|
}
|
|
|
|
|
2012-01-18 18:59:39 -07:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func (p *Paletted) Set(x, y int, c color.Color) {
|
2011-06-09 22:07:29 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-09 22:29:47 -06:00
|
|
|
p.Pix[i] = uint8(p.Palette.Index(c))
|
2011-06-09 22:07:29 -06:00
|
|
|
}
|
|
|
|
|
2009-09-20 20:08:03 -06:00
|
|
|
func (p *Paletted) ColorIndexAt(x, y int) uint8 {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return 0
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-09 22:29:47 -06:00
|
|
|
return p.Pix[i]
|
2009-09-20 20:08:03 -06:00
|
|
|
}
|
|
|
|
|
2009-09-10 22:33:44 -06:00
|
|
|
func (p *Paletted) SetColorIndex(x, y int, index uint8) {
|
2011-06-02 21:18:15 -06:00
|
|
|
if !(Point{x, y}.In(p.Rect)) {
|
2010-08-10 00:34:57 -06:00
|
|
|
return
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(x, y)
|
2011-07-09 22:29:47 -06:00
|
|
|
p.Pix[i] = index
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|
|
|
|
|
2011-06-02 02:51:41 -06:00
|
|
|
// 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 {
|
2011-07-09 22:29:47 -06:00
|
|
|
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,
|
|
|
|
}
|
|
|
|
}
|
2012-01-18 18:59:39 -07:00
|
|
|
i := p.PixOffset(r.Min.X, r.Min.Y)
|
2011-06-02 02:51:41 -06:00
|
|
|
return &Paletted{
|
2011-07-09 22:29:47 -06:00
|
|
|
Pix: p.Pix[i:],
|
2011-06-02 02:51:41 -06:00
|
|
|
Stride: p.Stride,
|
|
|
|
Rect: p.Rect.Intersect(r),
|
|
|
|
Palette: p.Palette,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-22 19:59:49 -06:00
|
|
|
// Opaque scans the entire image and reports whether it is fully opaque.
|
2010-06-03 18:18:26 -06:00
|
|
|
func (p *Paletted) Opaque() bool {
|
2011-07-07 00:32:19 -06:00
|
|
|
var present [256]bool
|
2011-07-09 22:29:47 -06:00
|
|
|
i0, i1 := 0, p.Rect.Dx()
|
2011-07-07 00:32:19 -06:00
|
|
|
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
|
|
|
|
}
|
2010-06-03 18:18:26 -06:00
|
|
|
_, _, _, a := c.RGBA()
|
|
|
|
if a != 0xffff {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2009-09-10 22:33:44 -06:00
|
|
|
// NewPaletted returns a new Paletted with the given width, height and palette.
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
func NewPaletted(r Rectangle, p color.Palette) *Paletted {
|
2011-09-14 05:39:49 -06:00
|
|
|
w, h := r.Dx(), r.Dy()
|
2011-07-12 00:39:38 -06:00
|
|
|
pix := make([]uint8, 1*w*h)
|
image: spin off a new color package out of the image package.
The spin-off renames some types. The new names are simply better:
image.Color -> color.Color
image.ColorModel -> color.Model
image.ColorModelFunc -> color.ModelFunc
image.PalettedColorModel -> color.Palette
image.RGBAColor -> color.RGBA
image.RGBAColorModel -> color.RGBAModel
image.RGBA64Color -> color.RGBA64
image.RGBA64ColorModel -> color.RGBA64Model
(similarly for NRGBAColor, GrayColorModel, etc)
The image.ColorImage type stays in the image package, but is renamed:
image.ColorImage -> image.Uniform
The image.Image implementations (image.RGBA, image.RGBA64, image.NRGBA,
image.Alpha, etc) do not change their name, and gain a nice symmetry:
an image.RGBA is an image of color.RGBA, etc.
The image.Black, image.Opaque uniform images remain unchanged (although
their type is renamed from image.ColorImage to image.Uniform). The
corresponding color types (color.Black, color.Opaque, etc) are new.
Nothing in the image/ycbcr is renamed yet. The ycbcr.YCbCrColor and
ycbcr.YCbCrImage types will eventually migrate to color.YCbCr and
image.YCbCr, but that will be a separate CL.
R=r, bsiegert
CC=golang-dev
https://golang.org/cl/5132048
2011-10-03 18:09:03 -06:00
|
|
|
return &Paletted{pix, 1 * w, r, p}
|
2009-09-10 22:33:44 -06:00
|
|
|
}
|