package pkg
|
|
import (
|
"bufio"
|
"bytes"
|
"encoding/base64"
|
"image"
|
"image/color"
|
"image/jpeg"
|
"log"
|
)
|
|
type Image struct {
|
Data []byte
|
Width int
|
Height int
|
}
|
|
type Rect struct {
|
Left int
|
Top int
|
Right int
|
Bottom int
|
}
|
|
func SubCutImage(srcImage []byte, rect *Rect, enlarge int) ([]byte, error) {
|
img, err := ReadImageData(srcImage)
|
if err != nil {
|
return nil, err
|
}
|
|
bkImg, _ := DataToImage(img.Data, img.Width, img.Height)
|
|
cutRect := image.Rect(rect.Left, rect.Top, rect.Right, rect.Bottom)
|
|
if enlarge > 0 {
|
enlargeRect := EnlargeCut(rect, img.Width, img.Height, enlarge)
|
squareRect := LetterBox(enlargeRect, img.Width, img.Height)
|
cutRect = image.Rect(squareRect.Left, squareRect.Top, squareRect.Right, squareRect.Bottom)
|
}
|
|
subImg := bkImg.(*image.RGBA).SubImage(cutRect)
|
|
dstImage, err := ImageToJpeg(subImg, nil)
|
if err != nil {
|
return nil, err
|
}
|
|
return dstImage, nil
|
}
|
|
func ReadImageData(srcImage []byte) (*Image, error) {
|
bt := bytes.NewBuffer(srcImage)
|
img, _, err := image.Decode(bt)
|
if err != nil {
|
return nil, err
|
}
|
|
bgr := Image2BGR(img)
|
|
return &Image{
|
Width: img.Bounds().Dx(),
|
Height: img.Bounds().Dy(),
|
Data: bgr,
|
}, nil
|
}
|
|
// letterbox 按照宽边修改目标框为正方形
|
func LetterBox(rect *Rect, maxW, maxH int) *Rect {
|
width := rect.Right - rect.Left
|
height := rect.Bottom - rect.Top
|
|
// 计算目标框的中心点坐标
|
centerX := (rect.Left + rect.Right) / 2
|
centerY := (rect.Top + rect.Bottom) / 2
|
|
// 如果宽度大于高度，则以高度为基准调整宽度，使其成为正方形
|
if width > height {
|
newWidth := height
|
newLeft := centerX - newWidth/2
|
newRight := centerX + newWidth/2
|
|
// 调整后的正方形框超出图像边界时的处理
|
if newLeft < 0 {
|
// 如果左边界超出，向右移动右边界
|
newRight += -newLeft
|
newLeft = 0
|
}
|
if newRight > maxW {
|
// 如果右边界超出，向左移动左边界
|
newLeft -= newRight - maxW
|
newRight = maxW
|
}
|
|
return &Rect{
|
Left: newLeft,
|
Top: rect.Top,
|
Right: newRight,
|
Bottom: rect.Bottom,
|
}
|
}
|
|
// 如果高度大于宽度，则以宽度为基准调整高度，使其成为正方形
|
if height > width {
|
newHeight := width
|
newTop := centerY - newHeight/2
|
newBottom := centerY + newHeight/2
|
|
// 调整后的正方形框超出图像边界时的处理
|
if newTop < 0 {
|
// 如果上边界超出，向下移动下边界
|
newBottom += -newTop
|
newTop = 0
|
}
|
if newBottom > maxH {
|
// 如果下边界超出，向上移动上边界
|
newTop -= newBottom - maxH
|
newBottom = maxH
|
}
|
|
return &Rect{
|
Left: rect.Left,
|
Top: newTop,
|
Right: rect.Right,
|
Bottom: newBottom,
|
}
|
}
|
|
// 如果宽度和高度相等，则已经是正方形，直接返回原始矩形
|
return rect
|
}
|
|
// 长宽变为一比一，每边各扩百分之...
|
func EnlargeCut(rect *Rect, maxW, maxH int, enlargePer int) *Rect {
|
// 先把长宽变为一比一
|
x0 := rect.Left
|
y0 := rect.Top
|
x1 := rect.Right
|
y1 := rect.Bottom
|
|
chaZhi := (y1 - y0) - (x1 - x0)
|
if chaZhi > 0 {
|
x0 = x0 - chaZhi/2
|
if x0 < 0 {
|
x0 = 0
|
}
|
x1 = x1 + chaZhi/2
|
if x1 > maxW {
|
x1 = maxW
|
}
|
} else {
|
y0 = y0 + chaZhi/2
|
if y0 < 0 {
|
y0 = 0
|
}
|
y1 = y1 - chaZhi/2
|
if y1 > maxH {
|
y1 = maxH
|
}
|
}
|
|
// 再把每边各扩大百分之...
|
enlarge := float32(enlargePer) / 100
|
x0New := int((1+enlarge)*float32(x0) - enlarge*float32(x1))
|
if x0New < 0 {
|
x0New = 0
|
}
|
|
x1New := int((1+enlarge)*float32(x1) - enlarge*float32(x0))
|
if x1New > maxW {
|
x1New = maxW
|
}
|
|
y0New := int((1+enlarge)*float32(y0) - enlarge*float32(y1))
|
if y0New < 0 {
|
y0New = 0
|
}
|
|
y1New := int((1+enlarge)*float32(y1) - enlarge*float32(y0))
|
if y1New > maxH {
|
y1New = maxH
|
}
|
|
return &Rect{
|
Left: x0New,
|
Top: y0New,
|
Right: x1New,
|
Bottom: y1New,
|
}
|
}
|
|
func DataToImage(data []byte, w, h int) (image.Image, error) {
|
width := w
|
height := h
|
step := w * 3
|
channels := 3
|
|
img := image.NewRGBA(image.Rect(0, 0, width, height))
|
c := color.RGBA{
|
R: uint8(0),
|
G: uint8(0),
|
B: uint8(0),
|
A: uint8(255),
|
}
|
|
for y := 0; y < height; y++ {
|
for x := 0; x < step; x = x + channels {
|
c.B = data[y*step+x]
|
c.G = data[y*step+x+1]
|
c.R = data[y*step+x+2]
|
//if channels == 4 {
|
// c.A = data[y*step+x+3]
|
//}
|
img.SetRGBA(x/channels, y, c)
|
}
|
}
|
|
return img, nil
|
}
|
|
// ImageToJpeg save to jpeg data
|
func ImageToJpeg(img image.Image, quality *int) ([]byte, error) {
|
var o *jpeg.Options
|
|
if quality != nil {
|
o = &jpeg.Options{Quality: *quality}
|
}
|
var b bytes.Buffer
|
w := bufio.NewWriter(&b)
|
err := jpeg.Encode(w, img, o)
|
if err != nil {
|
return nil, err
|
}
|
return b.Bytes(), err
|
}
|
|
// Image2BGR img->bgr
|
func Image2BGR(img image.Image) []byte {
|
bounds := img.Bounds()
|
x := bounds.Dx()
|
y := bounds.Dy()
|
data := make([]byte, 0, x*y*3)
|
for j := bounds.Min.Y; j < bounds.Max.Y; j++ {
|
for i := bounds.Min.X; i < bounds.Max.X; i++ {
|
r, g, b, _ := img.At(i, j).RGBA()
|
data = append(data, byte(b>>8), byte(g>>8), byte(r>>8))
|
}
|
}
|
return data
|
}
|
|
func DecodeBase64ToImage(data string) image.Image {
|
imgData, err := base64.StdEncoding.DecodeString(data)
|
if err != nil {
|
log.Fatal(err)
|
}
|
|
img, _, err := image.Decode(bytes.NewReader(imgData))
|
if err != nil {
|
log.Fatal(err)
|
}
|
|
return img
|
}
|
