登录
目录
当前位置： 首页 > 文档资料 > Go 语言标准库中文文档 >

image

优质
小牛编辑
128浏览
2023-12-01

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
  • type Image
  • type PalettedImage
  • type Config
  • func RegisterFormat(name, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error))
  • type Point
  • type Rectangle
  • type Uniform
  • type Alpha
  • type Alpha16
  • type Gray
  • type Gray16
  • type RGBA
  • type RGBA64
  • type NRGBA
  • type NRGBA64
  • type Paletted
  • type YCbCrSubsampleRatio
  • type YCbCr

    • Examples


  • package

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

    免责声明： 以上内容版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。感谢每一位辛勤著写的作者，感谢每一位的分享。
    @小牛知识库 xnip.cn