图片水印

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

package main

import (
    "flag"
    "fmt"
    "image"
    "image/draw"
    "image/jpeg"
    "image/png"
    "log"
    "math"
    "os"
    "path/filepath"
    "strings"
)

// 配置参数
type Config struct {
    SourcePath       string  // 原图路径
    WatermarkPath    string  // 水印图路径
    OutputPath       string  // 输出图片路径
    WatermarkScale   float64 // 水印缩放比例 (0.1-1.0)
    WatermarkDensity int     // 水印密集程度 (间隔像素)
}

// 加载图片
func loadImage(filePath string) (image.Image, error) {
     file, err := os.Open(filePath)
     if err != nil {
          return nil, err
     }
     defer file.Close()

     // 优先自动识别图片格式
     img, _, err := image.Decode(file)
     if err == nil {
          return img, nil
     }

     // fallback: 用后缀判断
     ext := strings.ToLower(filepath.Ext(filePath))
     _, _ = file.Seek(0, 0) // 重置文件指针
     switch ext {
     case ".jpg", ".jpeg":
          img, err = jpeg.Decode(file)
     case ".png":
          img, err = png.Decode(file)
     default:
          return nil, fmt.Errorf("不支持的图片格式: %s", ext)
     }
     return img, err
}

// 保存图片
func saveImage(img image.Image, outputPath string) error {
    file, err := os.Create(outputPath)
    if err != nil {
        return err
    }
    defer file.Close()

    ext := strings.ToLower(filepath.Ext(outputPath))

    switch ext {
    case ".jpg", ".jpeg":
        err = jpeg.Encode(file, img, &jpeg.Options{Quality: 90})
    case ".png":
        err = png.Encode(file, img)
    default:
        return fmt.Errorf("不支持的输出格式: %s", ext)
    }

    return err
}

// 调整水印图片大小
func resizeWatermark(watermark image.Image, scale float64) image.Image {
    bounds := watermark.Bounds()
    width := int(float64(bounds.Dx()) * scale)
    height := int(float64(bounds.Dy()) * scale)

    // 确保宽高至少为1像素
    if width < 1 {
        width = 1
    }
    if height < 1 {
        height = 1
    }

    resized := image.NewRGBA(image.Rect(0, 0, width, height))

    // 简单的缩放算法
    for y := 0; y < height; y++ {
        for x := 0; x < width; x++ {
            srcX := x * bounds.Dx() / width
            srcY := y * bounds.Dy() / height
            resized.Set(x, y, watermark.At(srcX, srcY))
        }
    }

    return resized
}

// 添加平铺水印
func addTiledWatermark(src image.Image, watermark image.Image, density int) image.Image {
    srcBounds := src.Bounds()
    watermarkBounds := watermark.Bounds()

    // 创建输出图像
    result := image.NewRGBA(srcBounds)
    draw.Draw(result, srcBounds, src, image.Point{}, draw.Src)

    // 计算水印平铺的行列数
    cols := int(math.Ceil(float64(srcBounds.Dx()) / float64(watermarkBounds.Dx()+density)))
    rows := int(math.Ceil(float64(srcBounds.Dy()) / float64(watermarkBounds.Dy()+density)))

    // 平铺水印
    for row := 0; row < rows; row++ {
        for col := 0; col < cols; col++ {
            x := col * (watermarkBounds.Dx() + density)
            y := row * (watermarkBounds.Dy() + density)

            // 水印位置
            watermarkPos := image.Rect(
                x,
                y,
                x+watermarkBounds.Dx(),
                y+watermarkBounds.Dy(),
            )

            // 确保水印不超出原图范围
            if watermarkPos.Max.X > srcBounds.Max.X || watermarkPos.Max.Y > srcBounds.Max.Y {
                watermarkPos = watermarkPos.Intersect(srcBounds)
            }

            // 绘制水印
            draw.Draw(result, watermarkPos, watermark, image.Point{}, draw.Over)
        }
    }

    return result
}

func main() {
    // 解析命令行参数
    config := Config{
        SourcePath:       "/Users/xxx/Downloads/yuantu.jpg",
        WatermarkPath:    "/Users/xxx/Downloads/shuiyin.png",
        OutputPath:       "/Users/xxx/Downloads/output.png",
        WatermarkScale:   0.8,
        WatermarkDensity: 50,
    }

    // flag.StringVar(&config.SourcePath, "src", "", "原图路径 (必填)")
    // flag.StringVar(&config.WatermarkPath, "watermark", "", "水印图路径 (必填)")
    // flag.StringVar(&config.OutputPath, "output", "output.jpg", "输出图片路径")
    // flag.Float64Var(&config.WatermarkScale, "scale", 0.3, "水印缩放比例 (0.1-1.0)")
    // flag.IntVar(&config.WatermarkDensity, "density", 50, "水印密集程度 (间隔像素)")

    flag.Parse()

    // 验证必填参数
    if config.SourcePath == "" || config.WatermarkPath == "" {
        fmt.Println("使用方法:")
        fmt.Println("  watermark -src <原图路径> -watermark <水印图路径> [选项]")
        fmt.Println("\n选项:")
        flag.PrintDefaults()
        os.Exit(1)
    }

    // 验证缩放比例范围
    if config.WatermarkScale < 0.1 || config.WatermarkScale > 1.0 {
        log.Fatal("水印缩放比例必须在 0.1 到 1.0 之间")
    }

    // 验证密集程度范围
    if config.WatermarkDensity < 0 {
        log.Fatal("水印密集程度必须大于等于 0")
    }

    // 加载原图
    srcImg, err := loadImage(config.SourcePath)
    if err != nil {
        log.Fatalf("加载原图失败: %v", err)
    }

    // 加载水印图
    watermarkImg, err := loadImage(config.WatermarkPath)
    if err != nil {
        log.Fatalf("加载水印图失败: %v", err)
    }

    // 调整水印大小
    resizedWatermark := resizeWatermark(watermarkImg, config.WatermarkScale)

    // 添加平铺水印
    resultImg := addTiledWatermark(srcImg, resizedWatermark, config.WatermarkDensity)

    // 保存结果
    if err := saveImage(resultImg, config.OutputPath); err != nil {
        log.Fatalf("保存图片失败: %v", err)
    }

    fmt.Printf("水印添加成功，已保存到: %s\n", config.OutputPath)
}