image包

import _ "image/png"

// 此示例演示如何解码JPEG图像并检查其像素。
package main

import (
	"encoding/base64"
	"fmt"
	"image"
	"log"
	"strings"

	// image/jpeg包未在下面的代码中明确使用，
	// 但导入的初始化副作用允许
	// image.Decode以了解JPEG格式的图像。 取消注释这
	// 两行也能理解GIF和PNG图像：
	// _ "image/gif"
	// _ "image/png"
	_ "image/jpeg"
)

func main() {
	// 解码JPEG数据。 如果从文件中读取，请创建一个阅读器
	// 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()

	// 计算m的红色，绿色，蓝色和alpha分量的16-bin直方图。
	//
	// 图像的边界不一定从（0,0）开始，因此两个循环开始
	// 在bounds.Min.Y和bounds.Min.X。 首先循环Y和X秒更多
	// 可能导致比X first和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()
			// 颜色的RGBA方法返回[0,65535]范围内的值。
			// 移位12将其减小到[0,15] .g的范围
			histogram[r>>12][0]++
			histogram[g>>12][1]++
			histogram[b>>12][2]++
			histogram[a>>12][3]++
		}
	}

	// 打印结果。
	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])
	}
}

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

var (
        // 黑色是不透明的黑色均匀图像。
        Black = NewUniform(color.Black)
        // 白色是不透明的白色均匀图像。
        White = NewUniform(color.White)
        // 透明是完全透明的均匀图像。
        Transparent = NewUniform(color.Transparent)
        // 不透明是完全不透明的均匀图像。
        Opaque = NewUniform(color.Opaque)
)

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

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

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
}

func NewAlpha(r Rectangle) *Alpha

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

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

func (p *Alpha) Bounds() Rectangle

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

func (p *Alpha) Opaque() bool

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

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

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

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

type Alpha16 struct {
        // Pix将图像的像素保存为big-endian格式的alpha值。 像素在
        // （x，y）从Pix [（y-Rect.Min.Y）* Stride +（x-Rect.Min.X）* 2]开始。
        Pix []uint8
        // Stride是垂直相邻像素之间的Pix步幅（以字节为单位）。
        Stride int
        // Rect是图像的边界。
        Rect Rectangle
}

func NewAlpha16(r Rectangle) *Alpha16

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

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

func (p *Alpha16) Bounds() Rectangle

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

func (p *Alpha16) Opaque() bool

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

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

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

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

type CMYK struct {
        // Pix以C，M，Y，K顺序保存图像的像素。 像素在
        // （x，y）从Pix [（y-Rect.Min.Y）* Stride +（x-Rect.Min.X）* 4]开始。
        Pix []uint8
        // Stride是垂直相邻像素之间的Pix步幅（以字节为单位）。
        Stride int
        // Rect是图像的边界。
        Rect Rectangle
}

func NewCMYK(r Rectangle) *CMYK

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

func (p *CMYK) Bounds() Rectangle

func (p *CMYK) CMYKAt(x, y int) color.CMYK

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

func (p *CMYK) Opaque() bool

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

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

func (p *CMYK) SetCMYK(x, y int, c color.CMYK)

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

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

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

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
}

func NewGray(r Rectangle) *Gray

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

func (p *Gray) Bounds() Rectangle

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

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

func (p *Gray) Opaque() bool

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

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

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

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

type Gray16 struct {
        // Pix将图像的像素保存为big-endian格式的灰度值。 像素在
        // （x，y）从Pix [（y-Rect.Min.Y）* Stride +（x-Rect.Min.X）* 2]开始。
        Pix []uint8
        // Stride是垂直相邻像素之间的Pix步幅（以字节为单位）。
        Stride int
        // Rect是图像的边界。
        Rect Rectangle
}

func NewGray16(r Rectangle) *Gray16

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

func (p *Gray16) Bounds() Rectangle

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

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

func (p *Gray16) Opaque() bool

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

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

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

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

type Image interface {
        // ColorModel返回Image的颜色模型。
        ColorModel() color.Model
        // Bounds返回At可以返回非零颜色的域。
        // 边界不一定包含点（0,0）。
        Bounds() Rectangle
        // 返回（x，y）处像素的颜色。
        // 在(Bounds().Min.X, Bounds().Min.Y)返回网格的左上角像素。
        // 在(Bounds().Max.X-1, Bounds().Max.Y-1) 返回右下角。
        At(x, y int) color.Color
}

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

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
}

func NewNRGBA(r Rectangle) *NRGBA

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

func (p *NRGBA) Bounds() Rectangle

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

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

func (p *NRGBA) Opaque() bool

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

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

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

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

type NRGBA64 struct {
        // Pix以R，G，B，A顺序和big-endian格式保存图像的像素。 像素在
        // （x，y）从Pix [（y-Rect.Min.Y）* Stride +（x-Rect.Min.X）* 8]开始。
        Pix []uint8
        // Stride是垂直相邻像素之间的Pix步幅（以字节为单位）。
        Stride int
        // Rect是图像的边界。
        Rect Rectangle
}

func NewNRGBA64(r Rectangle) *NRGBA64

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

func (p *NRGBA64) Bounds() Rectangle

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

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

func (p *NRGBA64) Opaque() bool

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

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

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

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

type NYCbCrA struct {
        YCbCr
        A       []uint8
        AStride int
}

func NewNYCbCrA(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA

func (p *NYCbCrA) AOffset(x, y int) int

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

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

func (p *NYCbCrA) NYCbCrAAt(x, y int) color.NYCbCrA

func (p *NYCbCrA) Opaque() bool

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

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 color.Palette
}

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

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

func (p *Paletted) Bounds() Rectangle

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

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

func (p *Paletted) Opaque() bool

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

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

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

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

type PalettedImage interface {
        // ColorIndexAt返回（x，y）处像素的调色板索引。
        ColorIndexAt(x, y int) uint8
        Image
}

type Point struct {
        X, Y int
}

var ZP Point

func Pt(X, Y int) Point

func (p Point) Add(q Point) Point

func (p Point) Div(k int) Point

func (p Point) Eq(q Point) bool

func (p Point) In(r Rectangle) bool

func (p Point) Mod(r Rectangle) Point

func (p Point) Mul(k int) Point

func (p Point) String() string

func (p Point) Sub(q Point) Point

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
}

func NewRGBA(r Rectangle) *RGBA

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

func (p *RGBA) Bounds() Rectangle

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

func (p *RGBA) Opaque() bool

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

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

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

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

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

type RGBA64 struct {
        // Pix以R，G，B，A顺序和big-endian格式保存图像的像素。 像素在
        // （x，y）从Pix [（y-Rect.Min.Y）* Stride +（x-Rect.Min.X）* 8]开始。
        Pix []uint8
        // Stride是垂直相邻像素之间的Pix步幅（以字节为单位）。
        Stride int
        // Rect是图像的边界。
        Rect Rectangle
}

func NewRGBA64(r Rectangle) *RGBA64

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

func (p *RGBA64) Bounds() Rectangle

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

func (p *RGBA64) Opaque() bool

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

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

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

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

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

type Rectangle struct {
        Min, Max Point
}

var ZR Rectangle

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

func (r Rectangle) Add(p Point) Rectangle

func (r Rectangle) At(x, y int) color.Color

func (r Rectangle) Bounds() Rectangle

func (r Rectangle) Canon() Rectangle

func (r Rectangle) ColorModel() color.Model

func (r Rectangle) Dx() int

func (r Rectangle) Dy() int

func (r Rectangle) Empty() bool

func (r Rectangle) Eq(s Rectangle) bool

func (r Rectangle) In(s Rectangle) bool

func (r Rectangle) Inset(n int) Rectangle

func (r Rectangle) Intersect(s Rectangle) Rectangle

func (r Rectangle) Overlaps(s Rectangle) bool

func (r Rectangle) Size() Point

func (r Rectangle) String() string

func (r Rectangle) Sub(p Point) Rectangle

func (r Rectangle) Union(s Rectangle) Rectangle

type Uniform struct {
        C color.Color
}

func NewUniform(c color.Color) *Uniform

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

func (c *Uniform) Bounds() Rectangle

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

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

func (c *Uniform) Opaque() bool

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

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.
For 4:1:1, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/4.
For 4:1:0, CStride == YStride/4 && len(Cb) == len(Cr) == len(Y)/8.

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

func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr

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

func (p *YCbCr) Bounds() Rectangle

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

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

func (p *YCbCr) Opaque() bool

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

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

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

type YCbCrSubsampleRatio int

const (
        YCbCrSubsampleRatio444 YCbCrSubsampleRatio = iota
        YCbCrSubsampleRatio422
        YCbCrSubsampleRatio420
        YCbCrSubsampleRatio440
        YCbCrSubsampleRatio411
        YCbCrSubsampleRatio410
)

func (s YCbCrSubsampleRatio) String() string