golang 六宫格、九宫格头像生成

陈银山

//Merge6Grid 6宫格　　//rule NO1:至少3张图 最多6张图
　　// NO2:第一张大小 60*60 其他大小 28*28 间隔4px 合成图大小102*102
　　// NO3:排列顺序 从左至右 从上到小 再 从右到左
　　// ++|
　　// ++|
　　// --|
　　func Merge6Grid(src []io.Reader, dst io.Writer) error {
　　defer func() {
　　if r := recover(); r != nil {
　　log.Println("Merge.recover:", r)
　　}
　　}()
　　if len(src) < 3 || len(src) > 6 {
　　panic("the pic num is between 3 and 6")
　　}
　　var err error
　　imagePoints := getXy6Grid(len(src))
　　//创建背景大图
　　background := image.NewRGBA(image.Rect(0, 0, 100, 100))
　　//设置背景为灰色
　　for m := 0; m < 100; m++ {
　　for n := 0; n < 100; n++ {
　　//rgba := GetRGBA(0xC8CED4)
　　background.SetRGBA(m, n, color.RGBA{127, 127, 127, 0})
　　}
　　}
　　//背景图矩形圆角
　　newBg, err := CreateRoundRectWithRGBA(background, 10)
　　if err != nil {
　　return err
　　}
　　//开始合成

　　var>　　for i, v := range imagePoints {
　　x := v.x
　　y := v.y
　　if i == 0 {
　　width = 60
　　} else {
　　width = 28
　　}
　　fOut := memory.NewWriter()
　　//先缩略

　　err = Scale(src, fOut,>　　if err != nil {
　　return err
　　}
　　//矩形圆角
　　rgba, err := CreateRoundRectWithoutColor(fOut, 6)
　　if err != nil {
　　return err
　　}
　　draw.Draw(newBg, newBg.Bounds(), rgba, rgba.Bounds().Min.Sub(image.Pt(x, y)), draw.Src)
　　}
　　return png.Encode(dst, newBg)
　　//return jpeg.Encode(dst, newBg, nil)
　　}
　　//CreateRoundRect 创建圆角矩形 r为输入图像 r为圆角半径 color为圆角颜色
　　func CreateRoundRect(rd io.Reader, r int, c *color.RGBA) (*image.RGBA, error) {
　　src, _, err := image.Decode(rd)
　　if err != nil {
　　return nil, err
　　}
　　b := src.Bounds()
　　x := b.Dx()
　　y := b.Dy()
　　dst := image.NewRGBA(b)
　　draw.Draw(dst, b, src, src.Bounds().Min, draw.Src)
　　p1 := image.Point{r, r}
　　p2 := image.Point{x - r, r}
　　p3 := image.Point{r, y - r}
　　p4 := image.Point{x - r, y - r}
　　for m := 0; m < x; m++ {
　　for n := 0; n < y; n++ {
　　if (p1.X-m)*(p1.X-m)+(p1.Y-n)*(p1.Y-n) > r*r && m  p2.X && n  r*r && m  p3.Y {
　　dst.Set(m, n, c)
　　} else if (p4.X-m)*(p4.X-m)+(p4.Y-n)*(p4.Y-n) > r*r && m > p4.X && n > p4.Y {
　　dst.Set(m, n, c)
　　}
　　}
　　}
　　return dst, nil
　　}
　　func CreateRoundRectWithoutColor(rd io.Reader, r int) (*image.RGBA, error) {
　　src, _, err := image.Decode(rd)
　　if err != nil {
　　return nil, err
　　}
　　b := src.Bounds()
　　x := b.Dx()
　　y := b.Dy()
　　dst := image.NewRGBA(b)
　　p1 := image.Point{r, r}
　　p2 := image.Point{x - r, r}
　　p3 := image.Point{r, y - r}
　　p4 := image.Point{x - r, y - r}
　　for m := 0; m < x; m++ {
　　for n := 0; n < y; n++ {
　　if (p1.X-m)*(p1.X-m)+(p1.Y-n)*(p1.Y-n) > r*r && m  p2.X && n  r*r && m  p3.Y {
　　} else if (p4.X-m)*(p4.X-m)+(p4.Y-n)*(p4.Y-n) > r*r && m > p4.X && n > p4.Y {
　　} else {
　　dst.Set(m, n, src.At(m, n))
　　}
　　}
　　}
　　return dst, nil
　　}
　　func CreateRoundRectWithRGBA(src *image.RGBA, r int) (*image.RGBA, error) {
　　b := src.Bounds()
　　x := b.Dx()
　　y := b.Dy()
　　dst := image.NewRGBA(b)
　　p1 := image.Point{r, r}
　　p2 := image.Point{x - r, r}
　　p3 := image.Point{r, y - r}
　　p4 := image.Point{x - r, y - r}
　　for m := 0; m < x; m++ {
　　for n := 0; n < y; n++ {
　　if (p1.X-m)*(p1.X-m)+(p1.Y-n)*(p1.Y-n) > r*r && m  p2.X && n  r*r && m  p3.Y {
　　} else if (p4.X-m)*(p4.X-m)+(p4.Y-n)*(p4.Y-n) > r*r && m > p4.X && n > p4.Y {
　　} else {
　　dst.Set(m, n, src.At(m, n))
　　}
　　}
　　}
　　return dst, nil
　　}
　　//0xC8CED4
　　func GetRGBA(c int) *color.RGBA {
　　var cl color.RGBA
　　cl.R = uint8((c >> 16) & 0xFF)
　　cl.G = uint8((c >> 8) & 0xFF)
　　cl.B = uint8(c & 0xFF)
　　return &cl
　　}
　　func getXy6Grid(size int) []*Point {

　　s := make([]*Point,>　　_x, _y := 4, 4
　　s[0] = &Point{_x, _y}
　　s[1] = &Point{60 + 2*_x, _y}
　　s[2] = &Point{60 + 2*_x, 28 + 2*_y}

　　if>　　s[3] = &Point{60 + 2*_x, 28*2 + 3*_y}
　　}

　　if>　　s[4] = &Point{28 + 2*_x, 60 + 2*_y}
　　}

　　if>　　s[5] = &Point{_x, 60 + 2*_y}
　　}
　　return s
　　}