# 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=
    `

## 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的范围）的新图像。返回值和原图像的像素数据是共用的。