package image

import "image"

image实现了基本的2D图片库。

基本接口叫作Image。图片的色彩定义在image/color包。

Image接口可以通过调用如NewRGBA和NewPaletted函数等获得；也可以通过调用Decode函数解码包含GIF、JPEG或PNG格式图像数据的输入流获得。解码任何具体图像类型之前都必须注册对应类型的解码函数。注册过程一般是作为包初始化的副作用，放在包的init函数里。因此，要解码PNG图像，只需在程序的main包里嵌入如下代码：

import _ "image/png"

_表示导入包但不使用包中的变量/函数/类型，只是为了包初始化函数的副作用。

参见http://golang.org/doc/articles/image_package.html

Example

// This example demonstrates decoding a JPEG image and examining its pixels.
package image_test
import (
    "encoding/base64"
    "fmt"
    "image"
    "log"
    "strings"
    // Package image/jpeg is not used explicitly in the code below,
    // but is imported for its initialization side-effect, which allows
    // image.Decode to understand JPEG formatted images. Uncomment these
    // two lines to also understand GIF and PNG images:
    // _ "image/gif"
    // _ "image/png"
    _ "image/jpeg"
)
func Example() {
    // Decode the JPEG data. If reading from file, create a reader with
    //
    // reader, err := os.Open("testdata/video-001.q50.420.jpeg")
    // if err != nil {
    //     log.Fatal(err)
    // }
    // defer reader.Close()
    reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
    m, _, err := image.Decode(reader)
    if err != nil {
        log.Fatal(err)
    }
    bounds := m.Bounds()
    // Calculate a 16-bin histogram for m's red, green, blue and alpha components.
    //
    // An image's bounds do not necessarily start at (0, 0), so the two loops start
    // at bounds.Min.Y and bounds.Min.X. Looping over Y first and X second is more
    // likely to result in better memory access patterns than X first and Y second.
    var histogram [16][4]int
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            r, g, b, a := m.At(x, y).RGBA()
            // A color's RGBA method returns values in the range [0, 65535].
            // Shifting by 12 reduces this to the range [0, 15].
            histogram[r>>12][0]++
            histogram[g>>12][1]++
            histogram[b>>12][2]++
            histogram[a>>12][3]++
        }
    }
    // Print the results.
    fmt.Printf("%-14s %6s %6s %6s %6s\n", "bin", "red", "green", "blue", "alpha")
    for i, x := range histogram {
        fmt.Printf("0x%04x-0x%04x: %6d %6d %6d %6d\n", i<<12, (i+1)<<12-1, x[0], x[1], x[2], x[3])
    }
    // Output:
    // bin               red  green   blue  alpha
    // 0x0000-0x0fff:    353    759   7228      0
    // 0x1000-0x1fff:    629   2944   1036      0
    // 0x2000-0x2fff:   1075   2319    984      0
    // 0x3000-0x3fff:    838   2291    988      0
    // 0x4000-0x4fff:    540   1302    542      0
    // 0x5000-0x5fff:    319    971    263      0
    // 0x6000-0x6fff:    316    377    178      0
    // 0x7000-0x7fff:    581    280    216      0
    // 0x8000-0x8fff:   3457    228    274      0
    // 0x9000-0x9fff:   2294    237    334      0
    // 0xa000-0xafff:    938    283    370      0
    // 0xb000-0xbfff:    322    338    401      0
    // 0xc000-0xcfff:    229    386    295      0
    // 0xd000-0xdfff:    263    416    281      0
    // 0xe000-0xefff:    538    433    312      0
    // 0xf000-0xffff:   2758   1886   1748  15450
}
const data = `
/9j/4AAQSkZJRgABAQIAHAAcAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdA
SFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2Nj
Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCABnAJYDASIAAhEBAxEB/8QA
HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh
MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW
V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG
x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF
BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV
YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE
hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq
8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDlwKMD0pwzSiuK57QzGDxS7D6in8Y5ximnAPUfSlcq4m3ilUYp
2OKXHvRcVxnTtS7c07HNFK4DQPakC4PNOA+tOx70XAjK/So5gBGP94fzqfvUVx/qxx/EP51UXqRP4WSE
cmgjilP3jSEZqS0IO/NGDnpUiocDg/McDjvV6HTPOdVWYgsM5KcfzzQ2JySM2jp6VYu7SWzmMUwG4cgj
kMPUVBjjtTGtRu0Zopw+lFFxhinrGzuqqMsxAA9yaXFSRv5cqSEcIwYj6GpuZ30O30fSLKzhUpbpNMv3
5XGTn29BV28jt7pPLuIVljPBBFVreYx+VbqAjycgt3x14zRcNOxGyVFHQkIc/wA61exyKLbuzjdZ046d
ftEuTEw3Rk9SPT8P8Kpbea3tchbyVae4JkjbbGpGdwOM89Af6ViFTWUtGdcXoM2+woK1JtpNtTcoZt+l
Jt7ZqTbRtouFyPFRXI/c9D94fzqzioLsfuD/ALw/nVReqIn8LJCOTSY+tSMOTmkIpXLRu+F0t5pJxPHG
wjjUAuBjJJz1+laD6Pai+WaK9SBX6puzn6ZP+NV/Dkdtc6ZNbyAFwxLAHDYPv6VoQ21nPNEEiQGEFRtk
Gf0NaWTOeW7Of8QwGG4MRZnEbYXPJwRnOR0zWNXW+KrqBLUWi5EjbWCgcAA9c/gRXKYqZaGlK/LqMH0F
FLtHvRSNiYD2pSDTgpp6p0ywUHoTULXYxcktzrdCf7Xo8LP/AKyEmMNjJ46dfbFWJ5TDGNwB9lFUvDV9
YrbfYGbyrjcWG88S57g+vtV26ZIvMlumKwwjLZ6V0WfU54yTvYwtbubea2WNWbzg4bYQeBgj8OtYeKhj
u4y2HQxqxOD1xzxmrWAQCCGB6EGsaikndmsJxeiYzBo280/Z7UbayuaXGY5oIp+2lx9KLjIsVDeD/Rj/
ALy/zq1t96r3y4tT/vL/ADq4P3kRP4WSleTSFKkkKoCW4GaqNcMxIjXj1pxjKT0FKrGC1Nrw3vGrKkYz
5kTAr6455/HH510UdwPtRgWCbzF5+YYUf4Vwun39xpmoR3qASMmQUJwGU9Rnt/8AWrpbrxhb8/ZdOmaQ
gAGZwFH5ZJrpVKVlY5ZYhN6kXiu2eO/ikZlIljAAB5yM549OawSOOlPuLqe+umuLqTfM4OSOAo7ADsKh
hl/cRsTuJHPv7mlKi3sVTxNtGP20VJhThgSQaK52mnZnUqsWrpkyeUrr5pABOAPU1AGaXUCWJISHGPfP
P8qL7BiKnsMg46H3qrbzupbj5mPTPTpXVSglG551SpzSsXJ4/MBUgYIxyKpySyGBYJriV1D7kRpCVH4V
bSeNJ4xchni3DeqnBI+td7F4b0mKIRjT45VbktJlzk455+n6VtYzv2PNwFZWBHBGKVJDGVC54/nXQeMN
NttLNkba1jgWVWDmM8bhg4/nzXLSSbXVj6fyNKUdNRp21RtIRJGrjuM0u3FQ2DbodvcEkfQmrW2vLqLl
k0ejCXNFMj2/jQV9qkxSYNRcsZiq2oI32N2CkhWXJxwOe9XMcVt6hoPn6dFaW0wgRpNzvKDlz6+/0rai
ryv2Jm9LHJai+ZRGCBjnr71ErdAxAY9B611t1Y2cunbbaOQ3FvKZI3UqGlZMbiWwfcfhV231iwvLSM3U
lt5Uq52TuZG+hGMA12xXJGxxzjzybOQtNOvb5j9ktZJhnBIHyg+5PFX38JayqK/2eLJIBUTgkDA9q7ex
itrSHFpGsUbndhRgc+g7VNIyfZJAoJZUbb3I46CtFJMylBo8sdWhmYMuCnylc9wef5VUT7+1chc5NS7h
sUZO5RtIPUH3pkBDOxxxmqM9TQtn+WilhHfHaik43KTG3Z4IyPyrNVjGCsZ+dmwv6V3cXhSG8sYpJLud
JJIwxChdoJGcYx/Wkg8DafA4knvLiQr/ALqj+VQpKw3FtnFFfvbiSMgZJ6/jXp2n3d9cQRBTFsKD96EP
oOxPU/8A68VVtbbRtMVntbePKDLTSHJH/Aj/AEqHTvE66rq72VugMMcbSGTnL4wMAfjT5n0HyW3L+s6b
baxaJBdzN+7bcrxkAhun0rz3VNCv7e7lgigknWI43xLu6jjIHTjtXqfkpPGVYsBkghTikgsYIN/lhgXb
cxLkknp/ShczQ7xtY8vtEmhkj8yGRBuCnehUcnHcVtmwfJ/fQ8e7f/E12txZW91C0U6b42xlST2OR/Ko
Bo1gM/uW55/1jf41nOipu7LhV5FZHIGzI6zwj/vr/Ck+yr3uYf8Ax7/CutbQdMb71tn/ALaN/jSf8I/p
X/PoP++2/wAan6rAr6wzkWt0II+1Rc/7Lf4Vd1eeCSKBbdZDdShYoiZNoyfY10P/AAj2lf8APmP++2/x
oPh/SjKspsozIuNrZORjp3qo0FHYPb3OZt7ae3SzjuItsiRSAgnccl/UA+3Q1yNjKLR4ZZYY5VD7tkv3
WwO/+e1evPp9nI257aJm6bioz1z1+tY+s6Hplnot9PbWMMcqwOFcLyOO1bJWMZSTOPHi+9w3mosrlyd2
9lCj02g9P/1e9a3hzxAbl2ikZRcdQueHHt7j864Y8Z4I4oRzG6urFWU5BHBB7HNJxTFGbR6he6Vpmtgm
eLy5zwZI/lb8fX8azIvBUUTHdfSFP4QsYB/HNZ+k+KEnRY75hHOvAk6K/v7H9K6yyvlnQBmDZ6GsnzR0
N0oy1RzOtaN/Y1tHNFO06u+zYy4I4Jzx9KKveJblXuordSGES5b6n/62PzorKVdp2LjQTVyWz8UWEWlq
jSgyxfJt6EgdDzWTdeLIZGO7zHI/hVajGmWWP+PWL8qwlAIURrhpMAHHJA71pRcZrToZzcoEuo6heakA
GHk245CZ6/X1qPTLq40q+W5t2QybSpDAkEEc55/zilk5k2r91eKhLDzWz2rpsczbbuemeD76fUNG865I
MiysmQMZAAwa3a5j4ftu0ByP+fh/5CulkLLG7INzhSVHqe1Fh3uOoqn9qQQxyhndmHIxwOmSR2xQ13KD
KoiBZOV9JBnt707MVy5RWdNdy7wRGf3bfMinnO1jg+vY03WXLaJO3mhQ20b0zwpYf0qlG7S7icrJs08U
VwumgC+YiQyeVtZH567hzj8aSL949oGhE/2v5pJCDkksQwBHC4/+vXQ8LZ2uYxxCavY7us/xCcaBfn0h
b+VP0bnSrb94ZMJgOecj1rl/GfidUE2k2gy5+SeQjgA/wj3rlas2jdao48qrjLAGkSKPk4Gc1WMj92I+
lIJnU8OfxPWo5inBokmtQTmM4OOh71b0q6vbFmWCbaxHyqQGAP0PT8KhSTzVyo5ocSKA5VfTOTmqsmRd
pl99XjPzThzK3zOeOSeveirNmkgg/fIpYsTkYORxRXmzlTjJqx6EVUcU7mhkKCzdAK59QI9zYxtG1fYU
UVtgtmY4nZEa8Ak9aqFv3rfSiiu1nMeifDv/AJF+T/r4f+QrqqKKQwzQenNFFMCOKFIgNuThdoJ5OPSk
ubeK6t3gnXdG4wwziiii/UTKMOg6dbzJLFE4dSCP3rEdeOM8805tDsGMvySgSsS6rM6gk9eAcUUVftZt
3uyVGNthuq3Eei6DK8H7sRR7YuMgHtXkc8rzTNLM26RyWY+p70UVnLY0iEsUipG7rhZBlDkc1HgYoorM
0HwyBXGeRjmrcUhMg2ghezd//rUUVcTKW5s2jZtY/QDaOKKKK8ip8bPRj8KP/9k=
`

Index

Examples

Variables

var (
    // Black是一个完全不透明的面积无限大的黑色图像
    Black = NewUniform(color.Black)
    // White是一个完全不透明的面积无限大的白色图像
    White = NewUniform(color.White)
    // Transparent是一个完全透明的面积无限大的图像
    Transparent = NewUniform(color.Transparent)
    // Opaque是一个完全不透明的面积无限大的图像
    Opaque = NewUniform(color.Opaque)
)

var ErrFormat = errors.New("image: unknown format")

ErrFormat说明解码时遇到了未知的格式。

type Image

type Image interface {
    // ColorModel方法返回图像的色彩模型
    ColorModel() color.Model
    // Bounds方法返回图像的范围，范围不一定包括点(0, 0)
    Bounds() Rectangle
    // At方法返回(x, y)位置的色彩
    // At(Bounds().Min.X, Bounds().Min.Y)返回网格左上角像素的色彩
    // At(Bounds().Max.X-1, Bounds().Max.Y-1) 返回网格右下角像素的色彩
    At(x, y int) color.Color
}

Image接口表示一个采用某色彩模型的颜色构成的有限矩形网格（即一幅图像）。

func Decode

func Decode(r io.Reader) (Image, string, error)

DecodeConfig函数解码并返回一个采用某种已注册格式编码的图像。字符串返回值是该格式注册时的名字。格式一般是在该编码格式的包的init函数中注册的。

type PalettedImage

type PalettedImage interface {
    // ColorIndexAt方法返回(x, y)位置的像素的（调色板）索引
    ColorIndexAt(x, y int) uint8
    Image
}

PalettedImage接口代表一幅图像，它的像素可能来自一个有限的调色板。

如果有对象m满足PalettedImage接口，且m.ColorModel()返回的color.Model接口底层为一个Palette类型值（记为p），则m.At(x, y)返回值应等于p[m.ColorIndexAt(x, y)]。如果m的色彩模型不是Palette，则ColorIndexAt的行为是不确定的。

type Config

type Config struct {
    ColorModel    color.Model
    Width, Height int
}

Config保管图像的色彩模型和尺寸信息。

func DecodeConfig

func DecodeConfig(r io.Reader) (Config, string, error)

DecodeConfig函数解码并返回一个采用某种已注册格式编码的图像的色彩模型和尺寸。字符串返回值是该格式注册时的名字。格式一般是在该编码格式的包的init函数中注册的。

func RegisterFormat

func RegisterFormat(name, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error))

RegisterFormat注册一个供Decode函数使用的图片格式。name是格式的名字，如"jpeg"或"png"；magic是该格式编码的魔术前缀，该字符串可以包含"?"通配符，每个通配符匹配一个字节；decode函数用于解码图片；decodeConfig函数只解码图片的配置。

type Point

type Point struct {
    X, Y int
}

Point是X, Y坐标对。坐标轴是向右（X）向下（Y）的。既可以表示点，也可以表示向量。

var ZP Point

ZP是原点。

func Pt

func Pt(X, Y int) Point

返回Point{X , Y}

func (Point) Eq

func (p Point) Eq(q Point) bool

报告p和q是否相同。

func (Point) Add

func (p Point) Add(q Point) Point

返回点Point{p.X+q.X, p.Y+q.Y}

func (Point) Sub

func (p Point) Sub(q Point) Point

返回点Point{p.X-q.X, p.Y-q.Y}

func (Point) Mul

func (p Point) Mul(k int) Point

返回点Point{p.X*k, p.Y*k}

func (Point) Div

func (p Point) Div(k int) Point

返回点Point{p.X/k, p.Y/k }

func (Point) In

func (p Point) In(r Rectangle) bool

报告p是否在r范围内。

func (Point) Mod

func (p Point) Mod(r Rectangle) Point

返回r范围内的某点q，满足p.X-q.X是r宽度的倍数，p.Y-q.Y是r高度的倍数。

func (Point) String

func (p Point) String() string

返回p的字符串表示。格式为"(3,4)"

type Rectangle

type Rectangle struct {
    Min, Max Point
}

Rectangle代表一个矩形。该矩形包含所有满足Min.X <= X < Max.X且Min.Y <= Y < Max.Y的点。如果两个字段满足Min.X <= Max.X且Min.Y <= Max.Y，就称该实例为规范格式的。矩形的方法，当输入是规范格式时，总是返回规范格式的输出。

var ZR Rectangle

ZR是矩形的零值。

func Rect

func Rect(x0, y0, x1, y1 int) Rectangle

返回一个矩形Rectangle{Pt(x0, y0), Pt(x1, y1)}。

func (Rectangle) Canon

func (r Rectangle) Canon() Rectangle

返回矩形的规范版本（左上&右下），方法必要时会交换坐标的最大值和最小值。

func (Rectangle) Dx

func (r Rectangle) Dx() int

返回r的宽度。

func (Rectangle) Dy

func (r Rectangle) Dy() int

返回r的高度。

func (Rectangle) Size

func (r Rectangle) Size() Point

返回r的宽度w和高度h构成的点Point{w, h}。

func (Rectangle) Empty

func (r Rectangle) Empty() bool

报告矩形是否为空矩形。（即内部不包含点的矩形）

func (Rectangle) Eq

func (r Rectangle) Eq(s Rectangle) bool

报告两个矩形是否相同。

func (Rectangle) In

func (r Rectangle) In(s Rectangle) bool

如果r包含的所有点都在s内，则返回真；否则返回假。

func (Rectangle) Overlaps

func (r Rectangle) Overlaps(s Rectangle) bool

如果r和s有非空的交集，则返回真；否则返回假。

func (Rectangle) Add

func (r Rectangle) Add(p Point) Rectangle

返回矩形按p（作为向量）平移后的新矩形。

func (Rectangle) Sub

func (r Rectangle) Sub(p Point) Rectangle

返回矩形按p（作为向量）反向平移后的新矩形。

func (Rectangle) Intersect

func (r Rectangle) Intersect(s Rectangle) Rectangle

返回两个矩形的交集矩形（同时被r和s包含的最大矩形）；如果r和s没有重叠会返回Rectangle零值。

func (Rectangle) Union

func (r Rectangle) Union(s Rectangle) Rectangle

返回同时包含r和s的最小矩形。

func (Rectangle) Inset

func (r Rectangle) Inset(n int) Rectangle

返回去掉矩形四周宽度n的框的矩形，n可为负数。如果n过大将返回靠近r中心位置的空矩形。

func (Rectangle) String

func (r Rectangle) String() string

返回矩形的字符串表示，格式为"(3,4)-(6,5)"。

type Uniform

type Uniform struct {
    C color.Color
}

Uniform类型代表一块面积无限大的具有同一色彩的图像。它实现了color.Color、color.Model和Image等接口。

func NewUniform

func NewUniform(c color.Color) *Uniform

func (*Uniform) At

func (c *Uniform) At(x, y int) color.Color

func (*Uniform) Bounds

func (c *Uniform) Bounds() Rectangle

func (*Uniform) ColorModel

func (c *Uniform) ColorModel() color.Model

func (*Uniform) Convert

func (c *Uniform) Convert(color.Color) color.Color

func (*Uniform) Opaque

func (c *Uniform) Opaque() bool

Opaque方法扫描整个图像并报告该图像是否是完全不透明的。

func (*Uniform) RGBA

func (c *Uniform) RGBA() (r, g, b, a uint32)

type Alpha

type Alpha struct {
    // Pix保管图像的像素，内容为alpha通道值（即透明度）。
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

Alpha类型代表一幅内存中的图像，其At方法返回color.Alpha类型的值。

func NewAlpha

func NewAlpha(r Rectangle) *Alpha

NewAlpha函数创建并返回一个具有指定宽度和高度的Alpha。

func (*Alpha) At

func (p *Alpha) At(x, y int) color.Color

func (*Alpha) Bounds

func (p *Alpha) Bounds() Rectangle

func (*Alpha) ColorModel

func (p *Alpha) ColorModel() color.Model

func (*Alpha) Opaque

func (p *Alpha) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*Alpha) PixOffset

func (p *Alpha) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*Alpha) Set

func (p *Alpha) Set(x, y int, c color.Color)

func (*Alpha) SetAlpha

func (p *Alpha) SetAlpha(x, y int, c color.Alpha)

func (*Alpha) SubImage

func (p *Alpha) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type Alpha16

type Alpha16 struct {
    // Pix保管图像的像素，内容为alpha通道值（即透明度，大端在前的格式）。
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*2]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

Alpha16类型代表一幅内存中的图像，其At方法返回color.Alpha16类型的值。

func NewAlpha16

func NewAlpha16(r Rectangle) *Alpha16

NewAlpha16函数创建并返回一个具有指定范围的Alpha16。

func (*Alpha16) At

func (p *Alpha16) At(x, y int) color.Color

func (*Alpha16) Bounds

func (p *Alpha16) Bounds() Rectangle

func (*Alpha16) ColorModel

func (p *Alpha16) ColorModel() color.Model

func (*Alpha16) Opaque

func (p *Alpha16) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*Alpha16) PixOffset

func (p *Alpha16) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*Alpha16) Set

func (p *Alpha16) Set(x, y int, c color.Color)

func (*Alpha16) SetAlpha16

func (p *Alpha16) SetAlpha16(x, y int, c color.Alpha16)

func (*Alpha16) SubImage

func (p *Alpha16) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type Gray

type Gray struct {
    // Pix保管图像的像素，内容为灰度。
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

Gray类型代表一幅内存中的图像，其At方法返回color.Gray类型的值。

func NewGray

func NewGray(r Rectangle) *Gray

NewGray函数创建并返回一个具有指定范围的Gray。

func (*Gray) At

func (p *Gray) At(x, y int) color.Color

func (*Gray) Bounds

func (p *Gray) Bounds() Rectangle

func (*Gray) ColorModel

func (p *Gray) ColorModel() color.Model

func (*Gray) Opaque

func (p *Gray) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*Gray) PixOffset

func (p *Gray) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*Gray) Set

func (p *Gray) Set(x, y int, c color.Color)

func (*Gray) SetGray

func (p *Gray) SetGray(x, y int, c color.Gray)

func (*Gray) SubImage

func (p *Gray) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type Gray16

type Gray16 struct {
    // Pix保管图像的像素，内容为灰度（大端在前的格式）。
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*2]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

Gray16类型代表一幅内存中的图像，其At方法返回color.Gray16类型的值。

func NewGray16

func NewGray16(r Rectangle) *Gray16

NewGray16函数创建并返回一个具有指定范围的Gray16。

func (*Gray16) At

func (p *Gray16) At(x, y int) color.Color

func (*Gray16) Bounds

func (p *Gray16) Bounds() Rectangle

func (*Gray16) ColorModel

func (p *Gray16) ColorModel() color.Model

func (*Gray16) Opaque

func (p *Gray16) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*Gray16) PixOffset

func (p *Gray16) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*Gray16) Set

func (p *Gray16) Set(x, y int, c color.Color)

func (*Gray16) SetGray16

func (p *Gray16) SetGray16(x, y int, c color.Gray16)

func (*Gray16) SubImage

func (p *Gray16) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type RGBA

type RGBA struct {
    // Pix保管图像的像素色彩信息，顺序为R, G, B, A
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

RGBA类型代表一幅内存中的图像，其At方法返回color.RGBA类型的值。

func NewRGBA

func NewRGBA(r Rectangle) *RGBA

NewRGBA函数创建并返回一个具有指定范围的RGBA。

func (*RGBA) At

func (p *RGBA) At(x, y int) color.Color

func (*RGBA) Bounds

func (p *RGBA) Bounds() Rectangle

func (*RGBA) ColorModel

func (p *RGBA) ColorModel() color.Model

func (*RGBA) Opaque

func (p *RGBA) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*RGBA) PixOffset

func (p *RGBA) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*RGBA) Set

func (p *RGBA) Set(x, y int, c color.Color)

func (*RGBA) SetRGBA

func (p *RGBA) SetRGBA(x, y int, c color.RGBA)

func (*RGBA) SubImage

func (p *RGBA) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type RGBA64

type RGBA64 struct {
    // Pix保管图像的像素色彩信息，顺序为R, G, B, A（每个值都是大端在前的格式）
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*8]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

RGBA64类型代表一幅内存中的图像，其At方法返回color.RGBA64类型的值

func NewRGBA64

func NewRGBA64(r Rectangle) *RGBA64

NewRGBA64函数创建并返回一个具有指定范围的RGBA64

func (*RGBA64) At

func (p *RGBA64) At(x, y int) color.Color

func (*RGBA64) Bounds

func (p *RGBA64) Bounds() Rectangle

func (*RGBA64) ColorModel

func (p *RGBA64) ColorModel() color.Model

func (*RGBA64) Opaque

func (p *RGBA64) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*RGBA64) PixOffset

func (p *RGBA64) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*RGBA64) Set

func (p *RGBA64) Set(x, y int, c color.Color)

func (*RGBA64) SetRGBA64

func (p *RGBA64) SetRGBA64(x, y int, c color.RGBA64)

func (*RGBA64) SubImage

func (p *RGBA64) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type NRGBA

type NRGBA struct {
    // Pix保管图像的像素色彩信息，顺序为R, G, B, A
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

NRGBA类型代表一幅内存中的图像，其At方法返回color.NRGBA类型的值。

func NewNRGBA

func NewNRGBA(r Rectangle) *NRGBA

NewNRGBA函数创建并返回一个具有指定范围的NRGBA。

func (*NRGBA) At

func (p *NRGBA) At(x, y int) color.Color

func (*NRGBA) Bounds

func (p *NRGBA) Bounds() Rectangle

func (*NRGBA) ColorModel

func (p *NRGBA) ColorModel() color.Model

func (*NRGBA) Opaque

func (p *NRGBA) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*NRGBA) PixOffset

func (p *NRGBA) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*NRGBA) Set

func (p *NRGBA) Set(x, y int, c color.Color)

func (*NRGBA) SetNRGBA

func (p *NRGBA) SetNRGBA(x, y int, c color.NRGBA)

func (*NRGBA) SubImage

func (p *NRGBA) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type NRGBA64

type NRGBA64 struct {
    // Pix保管图像的像素色彩信息，顺序为R, G, B, A（每个值都是大端在前的格式）
    // 像素(x, y)起始位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*8]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
}

NRGBA64类型代表一幅内存中的图像，其At方法返回color.NRGBA64类型的值。

func NewNRGBA64

func NewNRGBA64(r Rectangle) *NRGBA64

NewNRGBA64函数创建并返回一个具有指定范围的NRGBA64。

func (*NRGBA64) At

func (p *NRGBA64) At(x, y int) color.Color

func (*NRGBA64) Bounds

func (p *NRGBA64) Bounds() Rectangle

func (*NRGBA64) ColorModel

func (p *NRGBA64) ColorModel() color.Model

func (*NRGBA64) Opaque

func (p *NRGBA64) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*NRGBA64) PixOffset

func (p *NRGBA64) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*NRGBA64) Set

func (p *NRGBA64) Set(x, y int, c color.Color)

func (*NRGBA64) SetNRGBA64

func (p *NRGBA64) SetNRGBA64(x, y int, c color.NRGBA64)

func (*NRGBA64) SubImage

func (p *NRGBA64) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type Paletted

type Paletted struct {
    // Pix保存图像的象素，内容为调色板的索引。
    // 像素(x, y)的位置是Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1]
    Pix []uint8
    // Stride是Pix中每行像素占用的字节数
    Stride int
    // Rect是图像的范围
    Rect Rectangle
    // Palette是图像的调色板
    Palette color.Palette
}

Paletted类型是一幅采用uint8类型索引调色板的内存中的图像。

func NewPaletted

func NewPaletted(r Rectangle, p color.Palette) *Paletted

NewPaletted函数创建并返回一个具有指定范围、调色板的Paletted。

func (*Paletted) At

func (p *Paletted) At(x, y int) color.Color

func (*Paletted) Bounds

func (p *Paletted) Bounds() Rectangle

func (*Paletted) ColorIndexAt

func (p *Paletted) ColorIndexAt(x, y int) uint8

func (*Paletted) ColorModel

func (p *Paletted) ColorModel() color.Model

func (*Paletted) Opaque

func (p *Paletted) Opaque() bool

Opaque方法扫描整个图像并报告图像是否是完全不透明的。

func (*Paletted) PixOffset

func (p *Paletted) PixOffset(x, y int) int

PixOffset方法返回像素(x, y)的数据起始位置在Pix字段的偏移量/索引。

func (*Paletted) Set

func (p *Paletted) Set(x, y int, c color.Color)

func (*Paletted) SetColorIndex

func (p *Paletted) SetColorIndex(x, y int, index uint8)

func (*Paletted) SubImage

func (p *Paletted) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。

type YCbCrSubsampleRatio

type YCbCrSubsampleRatio int

YcbCrSubsampleRatio是YCbCr图像的色度二次采样比率。

const (
    YCbCrSubsampleRatio444 YCbCrSubsampleRatio = iota
    YCbCrSubsampleRatio422
    YCbCrSubsampleRatio420
    YCbCrSubsampleRatio440
)

func (YCbCrSubsampleRatio) String

func (s YCbCrSubsampleRatio) String() string

type YCbCr

type YCbCr struct {
    Y, Cb, Cr      []uint8
    YStride        int
    CStride        int
    SubsampleRatio YCbCrSubsampleRatio
    Rect           Rectangle
}

YcbCr代表采用Y'CbCr色彩模型的一幅内存中的图像。每个像素都对应一个Y采样，但每个Cb/Cr采样对应多个像素。Ystride是两个垂直相邻的像素之间的Y组分的索引增量。CStride是两个映射到单独的色度采样的垂直相邻的像素之间的Cb/Cr组分的索引增量。虽然不作绝对要求，但Ystride字段和len(Y)一般应为8的倍数，并且：

For 4:4:4, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/1.
For 4:2:2, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/2.
For 4:2:0, CStride == YStride/2 && len(Cb) == len(Cr) == len(Y)/4.
For 4:4:0, CStride == YStride/1 && len(Cb) == len(Cr) == len(Y)/2.

func NewYCbCr

func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr

NewYCbCr函数创建并返回一个具有指定宽度、高度和二次采样率的YcbCr。

func (*YCbCr) At

func (p *YCbCr) At(x, y int) color.Color

func (*YCbCr) Bounds

func (p *YCbCr) Bounds() Rectangle

func (*YCbCr) ColorModel

func (p *YCbCr) ColorModel() color.Model

func (*YCbCr) Opaque

func (p *YCbCr) Opaque() bool

func (*YCbCr) COffset

func (p *YCbCr) COffset(x, y int) int

像素(X, Y)的Cb或Cr（色度）组分的数据起始位置在Cb/Cr字段的偏移量/索引。

func (*YCbCr) YOffset

func (p *YCbCr) YOffset(x, y int) int

像素(X, Y)的Y（亮度）组分的数据起始位置在Y字段的偏移量/索引。

func (*YCbCr) SubImage

func (p *YCbCr) SubImage(r Rectangle) Image

SubImage方法返回代表原图像一部分（r的范围）的新图像。返回值和原图像的像素数据是共用的。