Go 博客

Go 图像包

Nigel Tao
2011 年 9 月 21 日

简介

image 和 image/color 包定义了许多类型：color.Color 和 color.Model 描述颜色，image.Point 和 image.Rectangle 描述基本的二维几何图形，而 image.Image 将这两个概念结合起来表示一个矩形的颜色网格。一篇单独的文章介绍了使用 image/draw 包进行图像合成。

颜色和颜色模型

Color 是一个接口，它定义了任何可以被视为颜色的类型的最小方法集：可以转换为红、绿、蓝和 alpha 值的类型。转换可能是损耗性的，例如从 CMYK 或 YCbCr 色彩空间转换。

type Color interface {
    // RGBA returns the alpha-premultiplied red, green, blue and alpha values
    // for the color. Each value ranges within [0, 0xFFFF], but is represented
    // by a uint32 so that multiplying by a blend factor up to 0xFFFF will not
    // overflow.
    RGBA() (r, g, b, a uint32)
}

关于返回值有三个重要的细节。首先，红色、绿色和蓝色是 alpha 预乘的：一个完全饱和的红色，同时也是 25% 透明，用 RGBA 表示时，返回的 r 为 75%。其次，通道具有 16 位有效范围：100% 红色用 RGBA 表示时，返回的 r 为 65535，而不是 255，这样从 CMYK 或 YCbCr 转换就不会那么有损。第三，返回的类型是 uint32，即使最大值为 65535，以保证两个值的乘积不会溢出。当根据来自第三种颜色的 alpha 蒙版混合两种颜色时，会发生这种乘法运算，类似于Porter 和 Duff的经典代数。

dstr, dstg, dstb, dsta := dst.RGBA()
srcr, srcg, srcb, srca := src.RGBA()
_, _, _, m := mask.RGBA()
const M = 1<<16 - 1
// The resultant red value is a blend of dstr and srcr, and ranges in [0, M].
// The calculation for green, blue and alpha is similar.
dstr = (dstr*(M-m) + srcr*m) / M

如果我们使用非 alpha 预乘颜色，那么代码片段的最后一行会更加复杂，这就是 Color 使用 alpha 预乘值的原因。

image/color 包还定义了许多实现 Color 接口的具体类型。例如，RGBA 是一个结构体，它表示经典的“每个通道 8 位”颜色。

type RGBA struct {
    R, G, B, A uint8
}

请注意，RGBA 的 R 字段是范围在 [0, 255] 内的 8 位 alpha 预乘颜色。RGBA 通过将该值乘以 0x101 来满足 Color 接口，从而生成范围在 [0, 65535] 内的 16 位 alpha 预乘颜色。类似地，NRGBA 结构体类型表示 8 位非 alpha 预乘颜色，如 PNG 图像格式所用。当直接操作 NRGBA 的字段时，这些值是非 alpha 预乘的，但是当调用 RGBA 方法时，返回值是 alpha 预乘的。

Model 只是可以将 Color 转换为其他 Color 的东西，这可能是损耗性的。例如，GrayModel 可以将任何 Color 转换为去饱和的Gray。Palette 可以将任何 Color 转换为有限调色板中的一个。

type Model interface {
    Convert(c Color) Color
}

type Palette []Color

点和矩形

Point 是整数网格上的 (x, y) 坐标，轴向右和向下递增。它既不是像素也不是网格方块。Point 本身没有固有的宽度、高度或颜色，但下面的可视化使用一个小彩色方块。

type Point struct {
    X, Y int
}

p := image.Point{2, 1}

Rectangle 是整数网格上的一个轴对齐矩形，由其左上角和右下角的 Point 定义。Rectangle 也本身没有固有的颜色，但下面的可视化用细彩色线勾勒矩形，并标出它们的 Min 和 Max Point。

type Rectangle struct {
    Min, Max Point
}

为了方便起见，image.Rect(x0, y0, x1, y1) 等价于 image.Rectangle{image.Point{x0, y0}, image.Point{x1, y1}}，但输入起来容易得多。

Rectangle 在左上角包含，在右下角不包含。对于 Point p 和 Rectangle r，p.In(r) 当且仅当 r.Min.X <= p.X && p.X < r.Max.X，Y 也是如此。这类似于切片 s[i0:i1] 在低端包含，在高端不包含的方式。（与数组和切片不同，Rectangle 通常具有非零原点。）

r := image.Rect(2, 1, 5, 5)
// Dx and Dy return a rectangle's width and height.
fmt.Println(r.Dx(), r.Dy(), image.Pt(0, 0).In(r)) // prints 3 4 false

将 Point 添加到 Rectangle 会平移 Rectangle。点和矩形不受限于位于右下象限。

r := image.Rect(2, 1, 5, 5).Add(image.Pt(-4, -2))
fmt.Println(r.Dx(), r.Dy(), image.Pt(0, 0).In(r)) // prints 3 4 true

两个矩形的交集产生另一个矩形，它可能是空的。

r := image.Rect(0, 0, 4, 3).Intersect(image.Rect(2, 2, 5, 5))
// Size returns a rectangle's width and height, as a Point.
fmt.Printf("%#v\n", r.Size()) // prints image.Point{X:2, Y:1}

点和矩形按值传递和返回。接受 Rectangle 参数的函数与接受两个 Point 参数或四个 int 参数的函数一样高效。

图像

Image 将 Rectangle 中的每个网格方块映射到来自 Model 的 Color。“(x, y) 处的像素”指的是由点 (x, y)、(x+1, y)、(x+1, y+1) 和 (x, y+1) 定义的网格方块的颜色。

type Image interface {
    // ColorModel returns the Image's color model.
    ColorModel() color.Model
    // Bounds returns the domain for which At can return non-zero color.
    // The bounds do not necessarily contain the point (0, 0).
    Bounds() Rectangle
    // At returns the color of the pixel at (x, y).
    // At(Bounds().Min.X, Bounds().Min.Y) returns the upper-left pixel of the grid.
    // At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one.
    At(x, y int) color.Color
}

一个常见的错误是假设 Image 的边界从 (0, 0) 开始。例如，动画 GIF 包含一系列 Image，并且第一个之后的每个 Image 通常只保存发生变化的区域的像素数据，并且该区域不一定从 (0, 0) 开始。迭代 Image m 的像素的正确方法如下所示

b := m.Bounds()
for y := b.Min.Y; y < b.Max.Y; y++ {
 for x := b.Min.X; x < b.Max.X; x++ {
  doStuffWith(m.At(x, y))
 }
}

Image 实现不必基于像素数据的内存切片。例如，Uniform 是一个边界无限大且颜色均匀的 Image，其内存表示仅仅是该颜色。

type Uniform struct {
    C color.Color
}

但是，通常程序会希望基于切片的图像。像 RGBA 和 Gray（其他包将其称为 image.RGBA 和 image.Gray）这样的结构体类型保存像素数据的切片并实现 Image 接口。

type RGBA struct {
    // Pix holds the image's pixels, in R, G, B, A order. The pixel at
    // (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*4].
    Pix []uint8
    // Stride is the Pix stride (in bytes) between vertically adjacent pixels.
    Stride int
    // Rect is the image's bounds.
    Rect Rectangle
}

这些类型还提供了一个 Set(x, y int, c color.Color) 方法，允许一次修改一个像素的图像。

m := image.NewRGBA(image.Rect(0, 0, 640, 480))
m.Set(5, 5, color.RGBA{255, 0, 0, 255})

如果您正在读取或写入大量像素数据，那么直接访问这些结构体类型的 Pix 字段可能会更高效，但也更复杂。

基于切片的 Image 实现还提供了一个 SubImage 方法，它返回一个由相同数组支持的 Image。修改子图像的像素将影响原始图像的像素，类似于修改子切片 s[i0:i1] 的内容将影响原始切片 s 的内容的方式。

m0 := image.NewRGBA(image.Rect(0, 0, 8, 5))
m1 := m0.SubImage(image.Rect(1, 2, 5, 5)).(*image.RGBA)
fmt.Println(m0.Bounds().Dx(), m1.Bounds().Dx()) // prints 8, 4
fmt.Println(m0.Stride == m1.Stride)             // prints true

对于处理图像 Pix 字段的低级代码，请注意，遍历 Pix 会影响图像边界之外的像素。在上面的示例中，m1.Pix 覆盖的像素以蓝色阴影显示。更高级别的代码，例如 At 和 Set 方法或 image/draw 包，将将其操作剪裁到图像的边界。

图像格式

标准包库支持许多常见的图像格式，例如 GIF、JPEG 和 PNG。如果您知道源图像文件的格式，则可以直接从 io.Reader 解码。

import (
 "image/jpeg"
 "image/png"
 "io"
)

// convertJPEGToPNG converts from JPEG to PNG.
func convertJPEGToPNG(w io.Writer, r io.Reader) error {
 img, err := jpeg.Decode(r)
 if err != nil {
  return err
 }
 return png.Encode(w, img)
}

如果您有未知格式的图像数据，则 image.Decode 函数可以检测格式。已识别格式的集合是在运行时构建的，并且不限于标准包库中的那些格式。图像格式包通常在其 init 函数中注册其格式，并且主包将“下划线导入”此类包，仅仅是为了格式注册的副作用。

import (
 "image"
 "image/png"
 "io"

 _ "code.google.com/p/vp8-go/webp"
 _ "image/jpeg"
)

// convertToPNG converts from any recognized format to PNG.
func convertToPNG(w io.Writer, r io.Reader) error {
 img, _, err := image.Decode(r)
 if err != nil {
  return err
 }
 return png.Encode(w, img)
}