图像 | 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
}