1089 lines
25 KiB
Go
1089 lines
25 KiB
Go
package services
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/base64"
|
||
"fmt"
|
||
"image"
|
||
"image/color"
|
||
"image/jpeg"
|
||
"image/png"
|
||
"math"
|
||
"os"
|
||
"path/filepath"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"github.com/disintegration/imaging"
|
||
"github.com/signintech/gopdf"
|
||
_ "golang.org/x/image/webp"
|
||
)
|
||
|
||
// supportedFormats lists formats that imaging.Open() can handle
|
||
var supportedFormats = map[string]bool{
|
||
".jpg": true,
|
||
".jpeg": true,
|
||
".png": true,
|
||
".gif": true,
|
||
".bmp": true,
|
||
".tiff": true,
|
||
".tif": true,
|
||
".webp": true,
|
||
}
|
||
|
||
func (s *ImageService) checkFormat(filePath string) error {
|
||
ext := strings.ToLower(filepath.Ext(filePath))
|
||
if ext == ".ico" {
|
||
return fmt.Errorf("ICO 格式暂不支持，请先转换为 PNG 或 JPG 格式")
|
||
}
|
||
if !supportedFormats[ext] {
|
||
return fmt.Errorf("不支持的图片格式: %s", ext)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type ImageService struct{}
|
||
|
||
func NewImageService() *ImageService {
|
||
return &ImageService{}
|
||
}
|
||
|
||
type ImageInfo struct {
|
||
Width int `json:"width"`
|
||
Height int `json:"height"`
|
||
Format string `json:"format"`
|
||
FilePath string `json:"filePath"`
|
||
Size int64 `json:"size"`
|
||
}
|
||
|
||
func (s *ImageService) GetImageInfo(filePath string) (*ImageInfo, error) {
|
||
file, err := os.Open(filePath)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("打开图片文件失败: %v", err)
|
||
}
|
||
defer file.Close()
|
||
|
||
config, format, err := image.DecodeConfig(file)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("解码图片配置失败: %v", err)
|
||
}
|
||
|
||
fileInfo, err := os.Stat(filePath)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("获取文件信息失败: %v", err)
|
||
}
|
||
|
||
return &ImageInfo{
|
||
Width: config.Width,
|
||
Height: config.Height,
|
||
Format: format,
|
||
FilePath: filePath,
|
||
Size: fileInfo.Size(),
|
||
}, nil
|
||
}
|
||
|
||
func (s *ImageService) GetImageBase64(filePath string) (string, error) {
|
||
data, err := os.ReadFile(filePath)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
ext := strings.ToLower(filepath.Ext(filePath))
|
||
mimeType := "image/png"
|
||
switch ext {
|
||
case ".jpg", ".jpeg":
|
||
mimeType = "image/jpeg"
|
||
case ".gif":
|
||
mimeType = "image/gif"
|
||
case ".bmp":
|
||
mimeType = "image/bmp"
|
||
case ".webp":
|
||
mimeType = "image/webp"
|
||
case ".ico":
|
||
mimeType = "image/x-icon"
|
||
}
|
||
|
||
return "data:" + mimeType + ";base64," + base64.StdEncoding.EncodeToString(data), nil
|
||
}
|
||
|
||
func (s *ImageService) ConvertFormat(inputPath, outputPath, format string, quality int) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = ChangeExtension(inputPath, "."+format)
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
outExt := strings.ToLower(filepath.Ext(outputPath))
|
||
|
||
switch {
|
||
case outExt == ".jpg" || outExt == ".jpeg" || format == "jpeg" || format == "jpg":
|
||
if quality <= 0 || quality > 100 {
|
||
quality = 85
|
||
}
|
||
err = imaging.Save(img, outputPath, imaging.JPEGQuality(quality))
|
||
case outExt == ".png" || format == "png":
|
||
err = imaging.Save(img, outputPath, imaging.PNGCompressionLevel(png.BestCompression))
|
||
case outExt == ".gif" || format == "gif":
|
||
err = imaging.Save(img, outputPath, imaging.GIFNumColors(256))
|
||
case outExt == ".bmp" || format == "bmp":
|
||
err = imaging.Save(img, outputPath)
|
||
case outExt == ".tiff" || outExt == ".tif" || format == "tiff" || format == "tif":
|
||
err = imaging.Save(img, outputPath)
|
||
case format == "ico" || outExt == ".ico":
|
||
err = s.ConvertToICO(inputPath, outputPath, []int{16, 32, 48, 64, 128, 256})
|
||
default:
|
||
if quality <= 0 || quality > 100 {
|
||
quality = 85
|
||
}
|
||
err = imaging.Save(img, outputPath, imaging.JPEGQuality(quality))
|
||
}
|
||
|
||
if err != nil {
|
||
return fmt.Errorf("保存图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) ConvertToICO(inputPath, outputPath string, sizes []int) error {
|
||
if outputPath == "" {
|
||
outputPath = ChangeExtension(inputPath, ".ico")
|
||
}
|
||
|
||
srcImg, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
var images []image.Image
|
||
for _, size := range sizes {
|
||
resized := imaging.Resize(srcImg, size, size, imaging.Lanczos)
|
||
images = append(images, resized)
|
||
}
|
||
|
||
return encodeICO(outputPath, images)
|
||
}
|
||
|
||
func encodeICO(outputPath string, images []image.Image) error {
|
||
f, err := os.Create(outputPath)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer f.Close()
|
||
|
||
var pngDataBuffers [][]byte
|
||
for _, img := range images {
|
||
buf := new(bytes.Buffer)
|
||
if err := png.Encode(buf, img); err != nil {
|
||
return err
|
||
}
|
||
pngDataBuffers = append(pngDataBuffers, buf.Bytes())
|
||
}
|
||
|
||
header := make([]byte, 6)
|
||
header[0] = 0
|
||
header[1] = 0
|
||
header[2] = 1
|
||
header[3] = 0
|
||
count := uint16(len(images))
|
||
header[4] = byte(count)
|
||
header[5] = byte(count >> 8)
|
||
|
||
if _, err := f.Write(header); err != nil {
|
||
return err
|
||
}
|
||
|
||
offset := uint32(6 + len(images)*16)
|
||
for i, img := range images {
|
||
bounds := img.Bounds()
|
||
w := bounds.Dx()
|
||
h := bounds.Dy()
|
||
entry := make([]byte, 16)
|
||
if w > 255 {
|
||
w = 0
|
||
}
|
||
if h > 255 {
|
||
h = 0
|
||
}
|
||
entry[0] = byte(w)
|
||
entry[1] = byte(h)
|
||
entry[2] = 0
|
||
entry[3] = 0
|
||
entry[4] = 1
|
||
entry[5] = 0
|
||
entry[6] = 32
|
||
entry[7] = 0
|
||
dataSize := uint32(len(pngDataBuffers[i]))
|
||
entry[8] = byte(dataSize)
|
||
entry[9] = byte(dataSize >> 8)
|
||
entry[10] = byte(dataSize >> 16)
|
||
entry[11] = byte(dataSize >> 24)
|
||
entry[12] = byte(offset)
|
||
entry[13] = byte(offset >> 8)
|
||
entry[14] = byte(offset >> 16)
|
||
entry[15] = byte(offset >> 24)
|
||
if _, err := f.Write(entry); err != nil {
|
||
return err
|
||
}
|
||
offset += uint32(len(pngDataBuffers[i]))
|
||
_ = i
|
||
}
|
||
|
||
for _, data := range pngDataBuffers {
|
||
if _, err := f.Write(data); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) CompressImage(inputPath, outputPath string, quality int, maxWidth, maxHeight int) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if quality < 1 {
|
||
quality = 1
|
||
}
|
||
if quality > 100 {
|
||
quality = 100
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_compressed")
|
||
}
|
||
|
||
// 记录原始文件大小
|
||
originalInfo, err := os.Stat(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("获取原文件信息失败: %v", err)
|
||
}
|
||
originalSize := originalInfo.Size()
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
// 智能降采样：超大图片自动缩小到合理尺寸
|
||
bounds := img.Bounds()
|
||
width := bounds.Dx()
|
||
height := bounds.Dy()
|
||
|
||
// 如果未指定尺寸，对超大图片自动降采样
|
||
if maxWidth == 0 && maxHeight == 0 {
|
||
maxDim := 4000 // 超过4000px视为超大
|
||
if width > maxDim || height > maxDim {
|
||
ratio := float64(maxDim) / float64(max(width, height))
|
||
maxWidth = int(float64(width) * ratio)
|
||
maxHeight = int(float64(height) * ratio)
|
||
}
|
||
}
|
||
|
||
if maxWidth > 0 || maxHeight > 0 {
|
||
newWidth, newHeight := calculateResize(width, height, maxWidth, maxHeight)
|
||
if newWidth < width || newHeight < height {
|
||
img = imaging.Resize(img, newWidth, newHeight, imaging.Lanczos)
|
||
}
|
||
}
|
||
|
||
ext := strings.ToLower(filepath.Ext(outputPath))
|
||
|
||
switch ext {
|
||
case ".jpg", ".jpeg":
|
||
err = s.saveOptimizedJPEG(img, outputPath, quality)
|
||
case ".png":
|
||
err = s.saveOptimizedPNG(img, outputPath, quality)
|
||
case ".gif":
|
||
err = imaging.Save(img, outputPath, imaging.GIFNumColors(256))
|
||
case ".bmp":
|
||
err = imaging.Save(img, outputPath)
|
||
case ".tiff", ".tif":
|
||
err = imaging.Save(img, outputPath)
|
||
default:
|
||
err = s.saveOptimizedJPEG(img, outputPath, quality)
|
||
}
|
||
|
||
if err != nil {
|
||
return fmt.Errorf("保存压缩图片失败: %v", err)
|
||
}
|
||
|
||
// 检查压缩后的文件大小
|
||
compressedInfo, err := os.Stat(outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("获取压缩文件信息失败: %v", err)
|
||
}
|
||
compressedSize := compressedInfo.Size()
|
||
|
||
// 如果压缩后文件变大，删除压缩文件并返回提示
|
||
if compressedSize >= originalSize {
|
||
os.Remove(outputPath)
|
||
return fmt.Errorf("压缩后文件变大(%s → %s)，建议降低质量参数或选择JPEG格式",
|
||
formatSize(originalSize), formatSize(compressedSize))
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) ResizeImage(inputPath, outputPath string, width, height int, maintainRatio bool) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if width <= 0 || height <= 0 {
|
||
return fmt.Errorf("宽度和高度必须大于 0")
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_resized")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
if maintainRatio {
|
||
img = imaging.Fit(img, width, height, imaging.Lanczos)
|
||
} else {
|
||
img = imaging.Resize(img, width, height, imaging.Lanczos)
|
||
}
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存调整大小后的图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) RotateImage(inputPath, outputPath string, angle float64, bgColor string) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_rotated")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
var fillColor color.Color
|
||
switch bgColor {
|
||
case "white":
|
||
fillColor = color.White
|
||
case "black":
|
||
fillColor = color.Black
|
||
default:
|
||
fillColor = color.Transparent
|
||
}
|
||
|
||
img = imaging.Rotate(img, angle, fillColor)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存旋转后的图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) AddGrayscale(inputPath, outputPath string) error {
|
||
return s.AdjustGrayscale(inputPath, outputPath, 100)
|
||
}
|
||
|
||
func (s *ImageService) AdjustGrayscale(inputPath, outputPath string, intensity int) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_grayscale")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
if intensity >= 100 {
|
||
img = imaging.Grayscale(img)
|
||
} else if intensity > 0 {
|
||
gray := imaging.Grayscale(img)
|
||
img = blendImages(img, gray, float64(intensity)/100.0)
|
||
}
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存灰度图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func blendImages(src, gray image.Image, opacity float64) image.Image {
|
||
if opacity < 0 {
|
||
opacity = 0
|
||
}
|
||
if opacity > 1 {
|
||
opacity = 1
|
||
}
|
||
bounds := src.Bounds()
|
||
dst := image.NewRGBA(bounds)
|
||
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
|
||
for x := bounds.Min.X; x < bounds.Max.X; x++ {
|
||
r1, g1, b1, a1 := src.At(x, y).RGBA()
|
||
r2, g2, b2, _ := gray.At(x, y).RGBA()
|
||
r := uint8((float64(r1>>8)*(1-opacity) + float64(r2>>8)*opacity))
|
||
g := uint8((float64(g1>>8)*(1-opacity) + float64(g2>>8)*opacity))
|
||
b := uint8((float64(b1>>8)*(1-opacity) + float64(b2>>8)*opacity))
|
||
a := uint8(a1 >> 8)
|
||
dst.Set(x, y, color.RGBA{r, g, b, a})
|
||
}
|
||
}
|
||
return dst
|
||
}
|
||
|
||
func (s *ImageService) AdjustBrightness(inputPath, outputPath string, factor float64) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_bright")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.AdjustBrightness(img, factor)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存调整亮度后的图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) AdjustContrast(inputPath, outputPath string, factor float64) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_contrast")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.AdjustContrast(img, factor)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存调整对比度后的图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) AdjustSaturation(inputPath, outputPath string, factor float64) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_saturation")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.AdjustSaturation(img, factor)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存调整饱和度后的图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) FlipH(inputPath, outputPath string) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_fliph")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.FlipH(img)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存水平翻转图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) FlipV(inputPath, outputPath string) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_flipv")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.FlipV(img)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存垂直翻转图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) SharpenImage(inputPath, outputPath string, amount float64) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_sharpen")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.Sharpen(img, amount)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存锐化图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) BlurImage(inputPath, outputPath string, radius float64) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_blur")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.Blur(img, radius)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存模糊图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) InvertImage(inputPath, outputPath string) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_invert")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
img = imaging.Invert(img)
|
||
|
||
err = imaging.Save(img, outputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("保存反色图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *ImageService) RemoveBackground(inputPath, outputPath string, threshold int, bgColor *ColorRGB) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_nobg")
|
||
}
|
||
|
||
if threshold <= 0 {
|
||
threshold = 30
|
||
}
|
||
|
||
srcImg, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
bounds := srcImg.Bounds()
|
||
dst := image.NewRGBA(bounds)
|
||
|
||
maxDist := float64(threshold) / 100.0 * 441.67
|
||
|
||
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
|
||
for x := bounds.Min.X; x < bounds.Max.X; x++ {
|
||
r, g, b, _ := srcImg.At(x, y).RGBA()
|
||
r8 := uint8(r >> 8)
|
||
g8 := uint8(g >> 8)
|
||
b8 := uint8(b >> 8)
|
||
|
||
var isBg bool
|
||
if bgColor != nil {
|
||
dr := float64(int(r8) - bgColor.R)
|
||
dg := float64(int(g8) - bgColor.G)
|
||
db := float64(int(b8) - bgColor.B)
|
||
dist := math.Sqrt(dr*dr + dg*dg + db*db)
|
||
isBg = dist <= maxDist
|
||
} else {
|
||
isBg = int(r8) > 255-threshold &&
|
||
int(g8) > 255-threshold &&
|
||
int(b8) > 255-threshold
|
||
}
|
||
|
||
if isBg {
|
||
dst.Set(x, y, color.RGBA{0, 0, 0, 0})
|
||
} else {
|
||
dst.Set(x, y, srcImg.At(x, y))
|
||
}
|
||
}
|
||
}
|
||
|
||
err = imaging.Save(dst, outputPath, imaging.PNGCompressionLevel(png.BestCompression))
|
||
if err != nil {
|
||
return fmt.Errorf("保存去背景图片失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
type CropShape struct {
|
||
Type string `json:"type"`
|
||
X int `json:"x"`
|
||
Y int `json:"y"`
|
||
Width int `json:"width"`
|
||
Height int `json:"height"`
|
||
Radius int `json:"radius"`
|
||
Points []Point `json:"points"`
|
||
}
|
||
|
||
type Point struct {
|
||
X int `json:"x"`
|
||
Y int `json:"y"`
|
||
}
|
||
|
||
type ColorRGB struct {
|
||
R int `json:"r"`
|
||
G int `json:"g"`
|
||
B int `json:"b"`
|
||
}
|
||
|
||
func (s *ImageService) CropImageShape(inputPath, outputPath string, shape CropShape) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = GetOutputPath(inputPath, "_cropped")
|
||
}
|
||
|
||
srcImg, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("打开图片失败: %v", err)
|
||
}
|
||
|
||
switch shape.Type {
|
||
case "rectangle":
|
||
rect := image.Rect(shape.X, shape.Y, shape.X+shape.Width, shape.Y+shape.Height)
|
||
cropped := imaging.Crop(srcImg, rect)
|
||
return imaging.Save(cropped, outputPath)
|
||
|
||
case "circle":
|
||
cx := shape.X + shape.Width/2
|
||
cy := shape.Y + shape.Height/2
|
||
radius := shape.Width / 2
|
||
if shape.Height/2 < radius {
|
||
radius = shape.Height / 2
|
||
}
|
||
|
||
size := radius * 2
|
||
result := image.NewRGBA(image.Rect(0, 0, size, size))
|
||
for y := 0; y < size; y++ {
|
||
for x := 0; x < size; x++ {
|
||
if math.Sqrt(float64((x-radius)*(x-radius)+((y-radius)*(y-radius)))) <= float64(radius) {
|
||
result.Set(x, y, srcImg.At(cx-radius+x, cy-radius+y))
|
||
}
|
||
}
|
||
}
|
||
|
||
return imaging.Save(result, outputPath)
|
||
|
||
case "rounded":
|
||
rect := image.Rect(shape.X, shape.Y, shape.X+shape.Width, shape.Y+shape.Height)
|
||
cropped := imaging.Crop(srcImg, rect)
|
||
|
||
radius := shape.Radius
|
||
if radius <= 0 {
|
||
radius = 20
|
||
}
|
||
|
||
size := cropped.Bounds().Size()
|
||
result := image.NewRGBA(image.Rect(0, 0, size.X, size.Y))
|
||
for y := 0; y < size.Y; y++ {
|
||
for x := 0; x < size.X; x++ {
|
||
inCorner := false
|
||
if x < radius && y < radius {
|
||
dx := float64(radius - x)
|
||
dy := float64(radius - y)
|
||
if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
|
||
inCorner = true
|
||
}
|
||
} else if x >= size.X-radius && y < radius {
|
||
dx := float64(x - (size.X - radius - 1))
|
||
dy := float64(radius - y)
|
||
if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
|
||
inCorner = true
|
||
}
|
||
} else if x < radius && y >= size.Y-radius {
|
||
dx := float64(radius - x)
|
||
dy := float64(y - (size.Y - radius - 1))
|
||
if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
|
||
inCorner = true
|
||
}
|
||
} else if x >= size.X-radius && y >= size.Y-radius {
|
||
dx := float64(x - (size.X - radius - 1))
|
||
dy := float64(y - (size.Y - radius - 1))
|
||
if math.Sqrt(dx*dx+dy*dy) > float64(radius) {
|
||
inCorner = true
|
||
}
|
||
}
|
||
|
||
if !inCorner {
|
||
result.Set(x, y, cropped.At(cropped.Bounds().Min.X+x, cropped.Bounds().Min.Y+y))
|
||
}
|
||
}
|
||
}
|
||
|
||
return imaging.Save(result, outputPath)
|
||
|
||
case "polygon":
|
||
if len(shape.Points) < 3 {
|
||
return fmt.Errorf("多边形至少需要3个点")
|
||
}
|
||
|
||
minX, minY := shape.Points[0].X, shape.Points[0].Y
|
||
maxX, maxY := shape.Points[0].X, shape.Points[0].Y
|
||
for _, p := range shape.Points {
|
||
if p.X < minX {
|
||
minX = p.X
|
||
}
|
||
if p.Y < minY {
|
||
minY = p.Y
|
||
}
|
||
if p.X > maxX {
|
||
maxX = p.X
|
||
}
|
||
if p.Y > maxY {
|
||
maxY = p.Y
|
||
}
|
||
}
|
||
|
||
cropW := maxX - minX
|
||
cropH := maxY - minY
|
||
rect := image.Rect(minX, minY, maxX, maxY)
|
||
cropped := imaging.Crop(srcImg, rect)
|
||
|
||
result := image.NewRGBA(image.Rect(0, 0, cropW, cropH))
|
||
for y := 0; y < cropH; y++ {
|
||
for x := 0; x < cropW; x++ {
|
||
if pointInPolygon(x, y, shape.Points, minX, minY) {
|
||
result.Set(x, y, cropped.At(cropped.Bounds().Min.X+x, cropped.Bounds().Min.Y+y))
|
||
}
|
||
}
|
||
}
|
||
|
||
return imaging.Save(result, outputPath)
|
||
|
||
default:
|
||
rect := image.Rect(shape.X, shape.Y, shape.X+shape.Width, shape.Y+shape.Height)
|
||
cropped := imaging.Crop(srcImg, rect)
|
||
return imaging.Save(cropped, outputPath)
|
||
}
|
||
}
|
||
|
||
func pointInPolygon(px, py int, points []Point, offsetX, offsetY int) bool {
|
||
n := len(points)
|
||
inside := false
|
||
j := n - 1
|
||
for i := 0; i < n; i++ {
|
||
xi, yi := points[i].X-offsetX, points[i].Y-offsetY
|
||
xj, yj := points[j].X-offsetX, points[j].Y-offsetY
|
||
if yi == yj {
|
||
j = i
|
||
continue
|
||
}
|
||
if ((yi > py) != (yj > py)) && (px < (xj-xi)*(py-yi)/(yj-yi)+xi) {
|
||
inside = !inside
|
||
}
|
||
j = i
|
||
}
|
||
return inside
|
||
}
|
||
|
||
// calculateResize 计算保持宽高比的resize尺寸
|
||
func calculateResize(origW, origH, maxW, maxH int) (int, int) {
|
||
if maxW == 0 && maxH == 0 {
|
||
return origW, origH
|
||
}
|
||
|
||
ratioW := float64(origW) / float64(maxW)
|
||
ratioH := float64(origH) / float64(maxH)
|
||
|
||
var ratio float64
|
||
if maxW == 0 {
|
||
ratio = ratioH
|
||
} else if maxH == 0 {
|
||
ratio = ratioW
|
||
} else {
|
||
ratio = math.Max(ratioW, ratioH)
|
||
}
|
||
|
||
if ratio <= 1 {
|
||
return origW, origH // 无需缩小
|
||
}
|
||
|
||
newW := int(float64(origW) / ratio)
|
||
newH := int(float64(origH) / ratio)
|
||
return newW, newH
|
||
}
|
||
|
||
// saveOptimizedJPEG 使用优化的JPEG编码
|
||
func (s *ImageService) saveOptimizedJPEG(img image.Image, path string, quality int) error {
|
||
f, err := os.Create(path)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer f.Close()
|
||
|
||
// 使用标准JPEG编码器，imaging库已做优化
|
||
opts := &jpeg.Options{
|
||
Quality: quality,
|
||
}
|
||
return jpeg.Encode(f, img, opts)
|
||
}
|
||
|
||
// saveOptimizedPNG 根据质量选择最优PNG压缩级别
|
||
func (s *ImageService) saveOptimizedPNG(img image.Image, path string, quality int) error {
|
||
f, err := os.Create(path)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer f.Close()
|
||
|
||
// PNG压缩级别映射：quality越高，压缩越强（但速度慢）
|
||
var level png.CompressionLevel
|
||
if quality >= 90 {
|
||
level = png.BestCompression // 最大压缩
|
||
} else if quality >= 70 {
|
||
level = png.DefaultCompression
|
||
} else {
|
||
level = png.BestSpeed // 快速压缩
|
||
}
|
||
|
||
encoder := &png.Encoder{
|
||
CompressionLevel: level,
|
||
}
|
||
return encoder.Encode(f, img)
|
||
}
|
||
|
||
func (s *ImageService) ImageToPDF(inputPath, outputPath string) error {
|
||
if err := s.checkFormat(inputPath); err != nil {
|
||
return err
|
||
}
|
||
if outputPath == "" {
|
||
outputPath = ChangeExtension(inputPath, ".pdf")
|
||
}
|
||
|
||
img, err := imaging.Open(inputPath)
|
||
if err != nil {
|
||
return fmt.Errorf("open image failed: %v", err)
|
||
}
|
||
|
||
bounds := img.Bounds()
|
||
imgW := float64(bounds.Dx())
|
||
imgH := float64(bounds.Dy())
|
||
|
||
pdf := gopdf.GoPdf{}
|
||
pageW := 595.0
|
||
pageH := 842.0
|
||
|
||
scale := pageW / imgW
|
||
if imgH*scale > pageH {
|
||
scale = pageH / imgH
|
||
}
|
||
drawW := imgW * scale
|
||
drawH := imgH * scale
|
||
|
||
pdf.Start(gopdf.Config{PageSize: gopdf.Rect{W: pageW, H: pageH}})
|
||
pdf.AddPage()
|
||
|
||
if err := pdf.Image(inputPath, (pageW-drawW)/2, (pageH-drawH)/2, &gopdf.Rect{W: drawW, H: drawH}); err != nil {
|
||
return fmt.Errorf("embed image: %v", err)
|
||
}
|
||
|
||
return pdf.WritePdf(outputPath)
|
||
}
|
||
|
||
// StitchRequest 拼接参数
|
||
type StitchRequest struct {
|
||
InputPaths []string `json:"inputPaths"`
|
||
Direction string `json:"direction"` // "vertical" or "horizontal"
|
||
Gap int `json:"gap"` // 图片间距(px)
|
||
BgColor string `json:"bgColor"` // 背景色 hex, e.g. "#ffffff"
|
||
OutputPath string `json:"outputPath"`
|
||
}
|
||
|
||
func (s *ImageService) StitchImages(req StitchRequest) (string, error) {
|
||
if len(req.InputPaths) < 2 {
|
||
return "", fmt.Errorf("至少需要 2 张图片才能拼接")
|
||
}
|
||
|
||
direction := req.Direction
|
||
if direction == "" {
|
||
direction = "vertical"
|
||
}
|
||
|
||
bgColor := parseHexColor(req.BgColor, color.White)
|
||
|
||
// 加载所有图片
|
||
images := make([]image.Image, 0, len(req.InputPaths))
|
||
for _, p := range req.InputPaths {
|
||
img, err := imaging.Open(p)
|
||
if err != nil {
|
||
return "", fmt.Errorf("打开图片失败 %s: %v", p, err)
|
||
}
|
||
images = append(images, img)
|
||
}
|
||
|
||
// 计算拼接后尺寸
|
||
var totalW, totalH int
|
||
if direction == "vertical" {
|
||
for _, img := range images {
|
||
b := img.Bounds()
|
||
if b.Dx() > totalW {
|
||
totalW = b.Dx()
|
||
}
|
||
totalH += b.Dy()
|
||
}
|
||
if len(images) > 1 {
|
||
totalH += req.Gap * (len(images) - 1)
|
||
}
|
||
} else {
|
||
for _, img := range images {
|
||
b := img.Bounds()
|
||
totalW += b.Dx()
|
||
if b.Dy() > totalH {
|
||
totalH = b.Dy()
|
||
}
|
||
}
|
||
if len(images) > 1 {
|
||
totalW += req.Gap * (len(images) - 1)
|
||
}
|
||
}
|
||
|
||
// 创建画布
|
||
canvas := image.NewRGBA(image.Rect(0, 0, totalW, totalH))
|
||
// 填充背景色
|
||
for y := 0; y < totalH; y++ {
|
||
for x := 0; x < totalW; x++ {
|
||
canvas.Set(x, y, bgColor)
|
||
}
|
||
}
|
||
|
||
// 逐张绘制
|
||
offsetX, offsetY := 0, 0
|
||
for _, img := range images {
|
||
b := img.Bounds()
|
||
var dx, dy int
|
||
if direction == "vertical" {
|
||
dx = (totalW - b.Dx()) / 2
|
||
dy = offsetY
|
||
offsetY += b.Dy() + req.Gap
|
||
} else {
|
||
dx = offsetX
|
||
dy = (totalH - b.Dy()) / 2
|
||
offsetX += b.Dx() + req.Gap
|
||
}
|
||
// 绘制子图到画布
|
||
for y := 0; y < b.Dy(); y++ {
|
||
for x := 0; x < b.Dx(); x++ {
|
||
canvas.Set(dx+x, dy+y, img.At(b.Min.X+x, b.Min.Y+y))
|
||
}
|
||
}
|
||
}
|
||
|
||
outputPath := req.OutputPath
|
||
if outputPath == "" {
|
||
outputPath = filepath.Join(os.TempDir(), "xk_stitch_output.png")
|
||
}
|
||
|
||
f, err := os.Create(outputPath)
|
||
if err != nil {
|
||
return "", fmt.Errorf("创建输出文件失败: %v", err)
|
||
}
|
||
defer f.Close()
|
||
|
||
encoder := &png.Encoder{CompressionLevel: png.DefaultCompression}
|
||
if err := encoder.Encode(f, canvas); err != nil {
|
||
return "", fmt.Errorf("保存拼接图片失败: %v", err)
|
||
}
|
||
|
||
return outputPath, nil
|
||
}
|
||
|
||
func parseHexColor(hex string, fallback color.Color) color.Color {
|
||
hex = strings.TrimPrefix(hex, "#")
|
||
if len(hex) != 6 {
|
||
return fallback
|
||
}
|
||
r, err1 := strconv.ParseUint(hex[0:2], 16, 8)
|
||
g, err2 := strconv.ParseUint(hex[2:4], 16, 8)
|
||
b, err3 := strconv.ParseUint(hex[4:6], 16, 8)
|
||
if err1 != nil || err2 != nil || err3 != nil {
|
||
return fallback
|
||
}
|
||
return color.RGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: 255}
|
||
}
|