golang中image包用法

image包实现了一个基本的2D图像库，该包中包含基本的接口叫做image，这个里面包含color，这个将在image/color中描述，

image接口的值创建方式有如下几种：

１调用NewRGBA和NewPaletted

２解码一个包含gif.jpen或者png格式的image数据的io.Reader

首先介绍一些image接口

type Image    //image是一个从颜色模型中采取color.Color的矩形网格

type Image interface {
	ColorModel() color.Model　//ColorModel　返回图片的 color.Model
	Bounds() Rectangle　　　　//图片中非０color的区域
	At(x, y int) color.Color　　//返回指定点的像素color.Color
}

任何一个struct只要实现了image中的三个方法，便实现了image接口

func Decode(r io.Reader) (Image, string, error)　//Decode对一个根据指定格式进行编码的图片进行解码操作，string返回的是在注册过程中使用的格式化名字，如"gif"或者"jpeg"等．

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

RegisterFormat注册一个image格式给解码使用，name是格式化名字，例如＂jpeg"或者＂png＂,magic标明格式化编码的前缀，magic字符串中能够包含一个?字符，用来匹配任何一个字符，decode是用来解码＂编码图像"的函数，DecodeConfig是一个仅仅解码它的配置的函数．

type Alpha　//用来设置图片的透明度

type Alpha struct {
	
	Pix []uint8　　// Pix 存储图片的像素 ，像 alpha 值. 在（X,Y）的像素 starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*1].
	
	Stride int          // Stride 表示垂直两个像素之间的步幅（距离）

	Rect Rectangle　　// Rect 表示 图片边界.
}

func NewAlpha(r Rectangle) *Alpha       //利用给定矩形边界产生一个alpha
func (p *Alpha) AlphaAt(x, y int) color.Alpha      //获取指定点的透明度
func (p *Alpha) At(x, y int) color.Color　　　//获取指定点的color(指定点的红绿蓝的透明度)
func (p *Alpha) Bounds() Rectangle　　　//获取alpha的边界
func (p *Alpha) ColorModel() color.Model　//获取alpha的颜色模型
func (p *Alpha) Opaque() bool　　　　　　//检查alpha是否完全不透明
func (p *Alpha) PixOffset(x, y int) int　　　//获取指定像素相对于第一个像素的相对偏移量
func (p *Alpha) Set(x, y int, c color.Color)　//设定指定位置的color
func (p *Alpha) SetAlpha(x, y int, c color.Alpha)  //设定指定位置的alpha

func (p *Alpha) SubImage(r Rectangle) Image   //获取p图像中被r覆盖的子图像，父图像和子图像公用像素

下面举例说明其用法：

package main

import (
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"log"
	"os"
)

const (
	dx = 500
	dy = 200
)

func main() {

	file, err := os.Create("test.jpeg")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()
	alpha := image.NewAlpha(image.Rect(0, 0, dx, dy))
	for x := 0; x  
 
 
 
得到的图形如下所示：
 
 

 
 
 得到的文件如下; 
 
 
 

 
 
 
 

 type RGBA64
 
 
 
 
type RGBA64 struct {
	// Pix holds the image's pixels, in R, G, B, A order and big-endian format. The pixel at
	// (x, y) starts at Pix[(y-Rect.Min.Y)*Stride + (x-Rect.Min.X)*8].
	Pix []uint8
	// Stride is the Pix stride (in bytes) between vertically adjacent pixels.
	Stride int
	// Rect is the image's bounds.
	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　　　//利用两个坐标点来生成矩阵
 
 
 
 
type Rectangle struct {
	Min, Max Point
}
 
 
 func Rect(x0, y0, x1, y1 int) Rectangle　//Rect是Rectangle{Pt(x0, y0), Pt(x1, y1)}的一种简写形式 
 
 func (r Rectangle) Add(p Point) Rectangle　//矩阵中两个点都与指定的点求和组成一个新的矩阵 
 
 func (r Rectangle) Canon() Rectangle　　//返回标准格式的矩形，如果有必要的话，会进行最小值坐标和最大坐标的交换 
 
 func (r Rectangle) Dx() int　　　　　　　//返回矩阵宽度dx 
 
 func (r Rectangle) Dy() int　　　　　　　//返回矩阵高度dy 
 
 func (r Rectangle) Empty() bool            　　//判定是否该矩阵为空，即不包含任何point 
 
 func (r Rectangle) Eq(s Rectangle) bool    //判断两个矩阵是否相等，指的是完全重合 
 
 func (r Rectangle) In(s Rectangle) bool　　//判断一个矩阵是否在另外一个矩阵之内 
 
 
 
func (r Rectangle) Inset(n int) Rectangle　//返回根据n算出的嵌入的矩阵，计算方法是矩阵的每个坐标都减去n，求得的矩阵必须在已知矩阵内嵌，如果没有的话则返回空矩阵
 func (r Rectangle) Intersect(s Rectangle) Rectangle     //求两个矩阵的相交矩阵，如果两个矩阵不相交，则返回０矩阵
 func (r Rectangle) Overlaps(s Rectangle) bool　　//判断两个矩阵是否有交集，即判断两个矩阵是否有公共区域
 func (r Rectangle) Size() Point　　　　　　　//返回矩阵的宽和高，即dx和dy
 func (r Rectangle) String() string                         //返回矩阵的字符串表示
 func (r Rectangle) Sub(p Point) Rectangle　　//一个矩阵的两个坐标点同时减去一个指定的坐标点p，得到的一个新的矩阵
 func (r Rectangle) Union(s Rectangle) Rectangle　//两个矩阵的并集，这个是和Intersect（求两个矩阵的交集）相对的
 
 

 
 
举例说明Rectangle用法:
 
 
 
 
package main

import (
	"fmt"
	"image"
)

func main() {
	rt := image.Rect(0, 0, 100, 50)
	rt1 := image.Rect(100, 100, 10, 10)

	fmt.Println(rt1.Canon())      //(10,10)-(100,100)，rt1大小坐标交换位置
	fmt.Println(rt, rt1)          //(0,0)-(100,50) (10,10)-(100,100)
	fmt.Println(rt.Dx(), rt.Dy()) //100 50，返回矩阵的宽度和高度
	fmt.Println(rt.Empty())       //false，矩阵是否为空
	fmt.Println(rt.Eq(rt1))       //false，两个矩阵是否相等
	fmt.Println(rt.In(rt1))       //false，矩阵rt是否在矩阵rt1中
	fmt.Println(rt.Inset(10))     //(10,10)-(90,40)，查找内嵌矩阵，用原矩阵坐标点减去给定的值10得到的矩阵，该矩阵必须是原矩阵的内嵌矩阵

	if rt.Overlaps(rt1) {
		fmt.Println(rt.Intersect(rt1)) //(10,10)-(100,50) //求两个矩阵的交集
	}
	fmt.Println(rt.Size())                //(100,50)，求矩阵大小，其等价与（dx，dy）
	fmt.Println(rt.String())              //  (0,0)-(100,50)
	fmt.Println(rt.Sub(image.Pt(10, 10))) // (-10,-10)-(90,40)，求矩阵和一个点的差，用于将矩阵进行移位操作
	fmt.Println(rt.Union(rt1))            //(0,0)-(100,100)，求两个矩阵的并集
}
 
 
 
 
 
 
type Uniform     //Uniform是一个具有统一颜色无穷大小的图片，它实现了color.Color, color.Model, 以及 Image的接口
 
 
 
 
type Uniform struct {
	C color.Color
}
 
 
 func NewUniform(c color.Color) *Uniform　　//根据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)　　　　//返回图片的r,g,b,a（红，绿，蓝，透明度）的值 
 
 
 

 type YCbCr　　//YCbCr是一个Y'CbCr颜色的图片，每个Y样本表示一个像素，但是每个Cb和Cr能够代表一个或者更多的像素，YStride是在相邻垂直像素的Ｙslice索引增　　　　　　　　　//量，CStride是Cb和 Cr　slice在相邻垂直像素（映射到独立色度采样）的索引增量．通常YStride和len(Y)是８的倍数，而CStride结果如下：
 
 
 
 
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.
 
 
 
 
 
 
 
 
type YCbCr struct {
	Y, Cb, Cr      []uint8
	YStride        int
	CStride        int
	SubsampleRatio YCbCrSubsampleRatio
	Rect           Rectangle
}
 
 
 func NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr　//通过给定边界和子样本比例创建新的YCbCr 
 
 func (p *YCbCr) At(x, y int) color.Color　　　　　//获取指定点的像素 
 
 func (p *YCbCr) Bounds() Rectangle　　　　　//获取图像边界 
 
 func (p *YCbCr) COffset(x, y int) int　　　　　　　//获取指定点相对于第一个Cb元素的像素点的相对位置 
 
 func (p *YCbCr) ColorModel() color.Model　　　　//获取颜色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　　　　　　　//获取相对于第一个Y元素的像素点的相对位置 
 
 
 

 type YCbCrSubsampleRatio　//YCbCr的色度子样本比例，常用于NewYCbCr(r Rectangle, subsampleRatio YCbCrSubsampleRatio)中用来创建YCbCr
 
 
 
 
const (
	YCbCrSubsampleRatio444 YCbCrSubsampleRatio = iota
	YCbCrSubsampleRatio422
	YCbCrSubsampleRatio420
	YCbCrSubsampleRatio440
)
 
 
 
 
 func (s YCbCrSubsampleRatio) String() string　//YCbCrSubsampleRatio结构的字符串表示