Python中使用PIL(Pillow)库给图片添加图片水印（第5节）

pip install Pillow

import os
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
from PIL import Image, ImageTk
import time

# 图片水印制作函数
def add_watermark(open_image, watermark_path, output_folder_path, position, opacity, watermark_scale_percent):
    try:
        # 获取原始图片文件名（包含扩展名）
        open_image_name = os.path.basename(open_image)
        file_name, file_extension = os.path.splitext(open_image_name)

        # 水印完成后，创建输出文件名，在原始文件名后添加_时间戳后缀
        # 获取当前时间的时间元组
        current_time = time.localtime()
        # 将时间元组格式化为字符串，例如，将时间“2025年08月23日09时22分30秒”格式化为“20250823092230”
        time_str = time.strftime("%Y%m%d%H%M%S", current_time)
        output_image_name = file_name + "_" + time_str + file_extension

        # 构建完整的输出文件路径
        output_path = os.path.join(output_folder_path, output_image_name)

        # 打开原始图片
        image = Image.open(open_image)
        image_width, image_height = image.size

        # 打开水印图片并确保其为RGBA模式
        watermark_image = Image.open(watermark_path)
        if watermark_image.mode!= 'RGBA':
            watermark_image = watermark_image.convert('RGBA')
        watermark_width, watermark_height = watermark_image.size

        # 将百分比转换为小数
        scale_percent = watermark_scale_percent / 100
        new_watermark_width = int(watermark_width * scale_percent)
        new_watermark_height = int(watermark_height * scale_percent)
        resized_watermark = watermark_image.resize((new_watermark_width, new_watermark_height))

        # 根据选择的位置调整水印位置
        if position == "左上":
            paste_position = (0, 0)
        elif position == "右上":
            paste_position = (image_width - new_watermark_width, 0)
        elif position == "居中":
            paste_position = (int((image_width - new_watermark_width)/2), int((image_height - new_watermark_height)/2))
        elif position == "左下":
            paste_position = (0, image_height - new_watermark_height)
        elif position == "右下":
            paste_position = (image_width - new_watermark_width, image_height - new_watermark_height)
        else:
            paste_position = (0, 0)

        # 处理透明度
        try:
            if opacity < 100:
                alpha = resized_watermark.split()[3]
                alpha = alpha.point(lambda p: p * opacity // 100)
                resized_watermark.putalpha(alpha)
        except Exception as e:
            messagebox.showerror("透明度处理错误", "出现错误，请检查水印图像。")

        # 创建空白图像，用于粘贴水印图片，大小为原水印图片的4倍，背景为透明色
        blank_image_dims = (round(4 * watermark_image.width),
                            round(4 * watermark_image.height))
        my_watermark = Image.new('RGBA', blank_image_dims, (255, 255, 255, 0))

        # 把水印图片粘贴在空白图像的中心位置，此方法可以避免原水印图片旋转过程导致尺寸变形
        watermark_position = (int(my_watermark.width/2), int(my_watermark.height/2))
        my_watermark.paste(resized_watermark, watermark_position)

        # 旋转图像
        try:
            # 判断输入的水印角度是否为空或者为非数字
            if current_tilt.get()=="" or not isinstance(current_tilt.get(), (int, float)):
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                # 如果水印角度输入不合法，则水印角度设置为0
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(0,
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
            else:
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(current_tilt.get(),
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
        except Exception as e:
            return

        # 添加水印
        image.paste(new_watermark_image, paste_position, new_watermark_image)

        # 保存结果图片，压缩质量为95%最高质量‌
        image.save(output_path, quality=95)
        messagebox.showinfo("完成", "水印已成功添加！")
    except Exception as e:
        messagebox.showerror("错误", "发生错误: " + str(e))

# 图片水印预览函数
def apply_watermark_preview():
    open_image = open_image_entry.get()
    watermark_path = watermark_entry.get()
    position = position_var.get()
    opacity = opacity_var.get().rstrip('%')
    opacity = int(opacity)
    watermark_scale_percent = scale_var.get().rstrip('%')
    watermark_scale_percent = int(watermark_scale_percent)
    if not open_image or not watermark_path:
        return

    try:
        # 打开原始图片
        image = Image.open(open_image)
        image_width, image_height = image.size

        # 打开水印图片并确保其为RGBA模式
        watermark_image = Image.open(watermark_path)
        if watermark_image.mode!= 'RGBA':
            watermark_image = watermark_image.convert('RGBA')
        watermark_width, watermark_height = watermark_image.size

        # 将百分比转换为小数
        scale_percent = watermark_scale_percent / 100
        new_watermark_width = int(watermark_width * scale_percent)
        new_watermark_height = int(watermark_height * scale_percent)
        resized_watermark = watermark_image.resize((new_watermark_width, new_watermark_height))

        # 根据选择的位置调整水印位置
        if position == "左上":
            paste_position = (0, 0)
        elif position == "右上":
            paste_position = (image_width - new_watermark_width, 0)
        elif position == "居中":
            paste_position = (int((image_width - new_watermark_width)/2), int((image_height - new_watermark_height)/2))
        elif position == "左下":
            paste_position = (0, image_height - new_watermark_height)
        elif position == "右下":
            paste_position = (image_width - new_watermark_width, image_height - new_watermark_height)
        else:
            paste_position = (0, 0)

        # 处理透明度
        try:
            if opacity < 100:
                alpha = resized_watermark.split()[3]
                alpha = alpha.point(lambda p: p * opacity // 100)
                resized_watermark.putalpha(alpha)
        except Exception as e:
            messagebox.showerror("透明度处理错误", "出现错误，请检查水印图像。")

        # 创建空白图像，用于粘贴水印图片，大小为原水印图片的4倍，背景为透明色
        blank_image_dims = (round(4 * watermark_image.width),
                            round(4 * watermark_image.height))
        my_watermark = Image.new('RGBA', blank_image_dims, (255, 255, 255, 0))

        # 把水印图片粘贴在空白图像的中心位置，此方法可以避免原水印图片旋转过程导致尺寸变形
        watermark_position = (int(my_watermark.width/2), int(my_watermark.height/2))
        my_watermark.paste(resized_watermark, watermark_position)

        # 旋转图像
        try:
            # 判断输入的水印角度是否为空或者为非数字
            if current_tilt.get()=="" or not isinstance(current_tilt.get(), (int, float)):
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                # 如果水印角度输入不合法，则水印角度设置为0
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(0,
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
            else:
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(current_tilt.get(),
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
        except Exception as e:
            return

        # 添加水印
        image.paste(new_watermark_image, paste_position, new_watermark_image)

        # 复制图片，创建带有水印的预览图像
        preview_image = image.copy()

        # 设置固定的预览框尺寸
        target_width = 400
        target_height = 400

        # 获取原始图片宽高比
        width_ratio = preview_image.width / target_width
        height_ratio = preview_image.height / target_height

        # 根据宽高比计算缩放后的尺寸，保持图片比例不变
        if width_ratio > height_ratio:
            new_width = target_width
            new_height = int(preview_image.height / width_ratio)
        else:
            new_height = target_height
            new_width = int(preview_image.width / height_ratio)

        # 缩放图片
        preview_image = preview_image.resize((new_width, new_height), Image.Resampling.LANCZOS)

        # 计算在预览框中居中显示的偏移量
        offset_x = (target_width - new_width) // 2
        offset_y = (target_height - new_height) // 2

        # 创建一个新的白色背景的图片（尺寸为预览框大小）
        final_preview_image = Image.new('RGB', (target_width, target_height), (255, 255, 255))
        final_preview_image.paste(preview_image, (offset_x, offset_y))

        # 转换为Tkinter可以显示的格式
        preview_photo = ImageTk.PhotoImage(final_preview_image)
        preview_canvas.create_image(0, 0, anchor='nw', image=preview_photo)
        preview_canvas.image = preview_photo

    except Exception as e:
        messagebox.showerror("预览错误", "无法显示水印预览: " + str(e))

import os
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
from PIL import Image, ImageTk
import time

# 图片水印制作函数
def add_watermark(open_image, watermark_path, output_folder_path, position, opacity, watermark_scale_percent):
    try:
        # 获取原始图片文件名（包含扩展名）
        open_image_name = os.path.basename(open_image)
        file_name, file_extension = os.path.splitext(open_image_name)

        # 水印完成后，创建输出文件名，在原始文件名后添加_时间戳后缀
        # 获取当前时间的时间元组
        current_time = time.localtime()
        # 将时间元组格式化为字符串，例如，将时间“2025年08月23日09时22分30秒”格式化为“20250823092230”
        time_str = time.strftime("%Y%m%d%H%M%S", current_time)
        output_image_name = file_name + "_" + time_str + file_extension

        # 构建完整的输出文件路径
        output_path = os.path.join(output_folder_path, output_image_name)

        # 打开原始图片
        image = Image.open(open_image)
        image_width, image_height = image.size

        # 打开水印图片并确保其为RGBA模式
        watermark_image = Image.open(watermark_path)
        if watermark_image.mode!= 'RGBA':
            watermark_image = watermark_image.convert('RGBA')
        watermark_width, watermark_height = watermark_image.size

        # 将百分比转换为小数
        scale_percent = watermark_scale_percent / 100
        new_watermark_width = int(watermark_width * scale_percent)
        new_watermark_height = int(watermark_height * scale_percent)
        resized_watermark = watermark_image.resize((new_watermark_width, new_watermark_height))

        # 根据选择的位置调整水印位置
        if position == "左上":
            paste_position = (0, 0)
        elif position == "右上":
            paste_position = (image_width - new_watermark_width, 0)
        elif position == "居中":
            paste_position = (int((image_width - new_watermark_width)/2), int((image_height - new_watermark_height)/2))
        elif position == "左下":
            paste_position = (0, image_height - new_watermark_height)
        elif position == "右下":
            paste_position = (image_width - new_watermark_width, image_height - new_watermark_height)
        else:
            paste_position = (0, 0)

        # 处理透明度
        try:
            if opacity < 100:
                alpha = resized_watermark.split()[3]
                alpha = alpha.point(lambda p: p * opacity // 100)
                resized_watermark.putalpha(alpha)
        except Exception as e:
            messagebox.showerror("透明度处理错误", "出现错误，请检查水印图像。")

        # 创建空白图像，用于粘贴水印图片，大小为原水印图片的4倍，背景为透明色
        blank_image_dims = (round(4 * watermark_image.width),
                            round(4 * watermark_image.height))
        my_watermark = Image.new('RGBA', blank_image_dims, (255, 255, 255, 0))

        # 把水印图片粘贴在空白图像的中心位置，此方法可以避免原水印图片旋转过程导致尺寸变形
        watermark_position = (int(my_watermark.width/2), int(my_watermark.height/2))
        my_watermark.paste(resized_watermark, watermark_position)

        # 旋转图像
        try:
            # 判断输入的水印角度是否为空或者为非数字
            if current_tilt.get()=="" or not isinstance(current_tilt.get(), (int, float)):
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                # 如果水印角度输入不合法，则水印角度设置为0
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(0,
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
            else:
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(current_tilt.get(),
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
        except Exception as e:
            return

        # 添加水印
        image.paste(new_watermark_image, paste_position, new_watermark_image)

        # 保存结果图片，压缩质量为95%最高质量‌
        image.save(output_path, quality=95)
        messagebox.showinfo("完成", "水印已成功添加！")
    except Exception as e:
        messagebox.showerror("错误", "发生错误: " + str(e))

# 打开文件选择对话框，用于选择“待加水印图片”
def browse_open_image():
    file_selected = filedialog.askopenfilename()
    if file_selected:
        open_image_entry.delete(0, tk.END)
        open_image_entry.insert(0, file_selected)
        apply_watermark_preview()

# 打开文件选择对话框，用于选择“水印图片”
def browse_watermark_image():
    file_selected = filedialog.askopenfilename()
    if file_selected:
        watermark_entry.delete(0, tk.END)
        watermark_entry.insert(0, file_selected)
        watermark_image = preprocess_watermark_image(file_selected)
        if watermark_image:
            apply_watermark_preview()

# 打开一个文件选择对话框，让用户选择水印图片保存后的目录
def browse_output_image():
    folder_selected = filedialog.askdirectory()
    if folder_selected:
        output_entry.delete(0, tk.END)
        output_entry.insert(0, folder_selected)

# 添加水印进程
def add_watermark_process():
    open_image = open_image_entry.get()
    watermark_path = watermark_entry.get()
    output_folder_path = output_entry.get()
    position = position_var.get()
    opacity = opacity_var.get().rstrip('%')
    opacity = int(opacity)
    watermark_scale_percent = scale_var.get().rstrip('%')
    watermark_scale_percent = int(watermark_scale_percent)
    # 判断是否为空
    if not open_image:
        messagebox.showwarning("警告", "“待加水印图片”不能为空！")
        return
    elif not watermark_path:
        messagebox.showwarning("警告", "“水印图片”不能为空！")
        return
    elif not output_folder_path:
        messagebox.showwarning("警告", "“输出文件夹”不能为空！")
        return
    add_watermark(open_image, watermark_path, output_folder_path, position, opacity, watermark_scale_percent)

# 图片水印预览函数
def apply_watermark_preview():
    open_image = open_image_entry.get()
    watermark_path = watermark_entry.get()
    position = position_var.get()
    opacity = opacity_var.get().rstrip('%')
    opacity = int(opacity)
    watermark_scale_percent = scale_var.get().rstrip('%')
    watermark_scale_percent = int(watermark_scale_percent)
    if not open_image or not watermark_path:
        return

    try:
        # 打开原始图片
        image = Image.open(open_image)
        image_width, image_height = image.size

        # 打开水印图片并确保其为RGBA模式
        watermark_image = Image.open(watermark_path)
        if watermark_image.mode!= 'RGBA':
            watermark_image = watermark_image.convert('RGBA')
        watermark_width, watermark_height = watermark_image.size

        # 将百分比转换为小数
        scale_percent = watermark_scale_percent / 100
        new_watermark_width = int(watermark_width * scale_percent)
        new_watermark_height = int(watermark_height * scale_percent)
        resized_watermark = watermark_image.resize((new_watermark_width, new_watermark_height))

        # 根据选择的位置调整水印位置
        if position == "左上":
            paste_position = (0, 0)
        elif position == "右上":
            paste_position = (image_width - new_watermark_width, 0)
        elif position == "居中":
            paste_position = (int((image_width - new_watermark_width)/2), int((image_height - new_watermark_height)/2))
        elif position == "左下":
            paste_position = (0, image_height - new_watermark_height)
        elif position == "右下":
            paste_position = (image_width - new_watermark_width, image_height - new_watermark_height)
        else:
            paste_position = (0, 0)

        # 处理透明度
        try:
            if opacity < 100:
                alpha = resized_watermark.split()[3]
                alpha = alpha.point(lambda p: p * opacity // 100)
                resized_watermark.putalpha(alpha)
        except Exception as e:
            messagebox.showerror("透明度处理错误", "出现错误，请检查水印图像。")

        # 创建空白图像，用于粘贴水印图片，大小为原水印图片的4倍，背景为透明色
        blank_image_dims = (round(4 * watermark_image.width),
                            round(4 * watermark_image.height))
        my_watermark = Image.new('RGBA', blank_image_dims, (255, 255, 255, 0))

        # 把水印图片粘贴在空白图像的中心位置，此方法可以避免原水印图片旋转过程导致尺寸变形
        watermark_position = (int(my_watermark.width/2), int(my_watermark.height/2))
        my_watermark.paste(resized_watermark, watermark_position)

        # 旋转图像
        try:
            # 判断输入的水印角度是否为空或者为非数字
            if current_tilt.get()=="" or not isinstance(current_tilt.get(), (int, float)):
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                # 如果水印角度输入不合法，则水印角度设置为0
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(0,
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
            else:
                # 将文本图像修剪为仅围绕文本中心旋转的图像
                text_box_size = my_watermark.getbbox()
                my_watermark = my_watermark.crop(text_box_size)
                new_watermark_image = my_watermark.rotate(current_tilt.get(),
                                            center=(my_watermark.width / 2, my_watermark.height / 2),
                                            expand=True)
        except Exception as e:
            return

        # 添加水印
        image.paste(new_watermark_image, paste_position, new_watermark_image)

        # 复制图片，创建带有水印的预览图像
        preview_image = image.copy()

        # 设置固定的预览框尺寸
        target_width = 400
        target_height = 400

        # 获取原始图片宽高比
        width_ratio = preview_image.width / target_width
        height_ratio = preview_image.height / target_height

        # 根据宽高比计算缩放后的尺寸，保持图片比例不变
        if width_ratio > height_ratio:
            new_width = target_width
            new_height = int(preview_image.height / width_ratio)
        else:
            new_height = target_height
            new_width = int(preview_image.width / height_ratio)

        # 缩放图片
        preview_image = preview_image.resize((new_width, new_height), Image.Resampling.LANCZOS)

        # 计算在预览框中居中显示的偏移量
        offset_x = (target_width - new_width) // 2
        offset_y = (target_height - new_height) // 2

        # 创建一个新的白色背景的图片（尺寸为预览框大小）
        final_preview_image = Image.new('RGB', (target_width, target_height), (255, 255, 255))
        final_preview_image.paste(preview_image, (offset_x, offset_y))

        # 转换为Tkinter可以显示的格式
        preview_photo = ImageTk.PhotoImage(final_preview_image)
        preview_canvas.create_image(0, 0, anchor='nw', image=preview_photo)
        preview_canvas.image = preview_photo

    except Exception as e:
        messagebox.showerror("预览错误", "无法显示水印预览: " + str(e))

# 选择水印位置时触发的函数
def on_position_change(event):
    apply_watermark_preview()

# 选择水印透明度时触发的函数
def on_opacity_change(event):
    apply_watermark_preview()

# 选择水印缩放比例时触发的函数
def on_scale_change(event):
    apply_watermark_preview()

# Spinbox控件点击箭头输入数字时触发的函数
def on_tilt_change(event):
    apply_watermark_preview()

#  Spinbox控件直接输入数字时触发的函数
def on_Release_change(event):
    apply_watermark_preview()

# 判断水印图片是否为RGBA模式，如果不是，则将图片转换为RGBA模式
def preprocess_watermark_image(watermark_path):
    try:
        watermark_image = Image.open(watermark_path)
        if watermark_image.mode!= 'RGBA':
            watermark_image = watermark_image.convert('RGBA')
        return watermark_image
    except Exception as e:
        messagebox.showerror("水印图像预处理错误", "出现错误，请检查水印图像。")
        return None

# 创建主窗口
app = tk.Tk()
app.title("给图片添加图片水印工具")
app.geometry("950x500")
app.resizable(False, False)

# 设置主窗口居中
app.update_idletasks()
window_width = app.winfo_width()
window_height = app.winfo_height()
screen_width = app.winfo_screenwidth()
screen_height = app.winfo_screenheight()
x = (screen_width - window_width) // 2
y = (screen_height - window_height) // 2
app.geometry(f"{window_width}x{window_height}+{x}+{y}")

# 添加水印预览区域
preview_frame = tk.Frame(app)
preview_frame.pack(side="left", pady=10, padx=20)

preview_label = tk.Label(preview_frame, text="水印图片预览:")
preview_label.grid(column=0, row=0, pady=5)

preview_canvas = tk.Canvas(preview_frame, width=400, height=400, bg="white")
preview_canvas.grid(column=0, row=1, pady=5)

# 待加水印图片选择
edit_image_frame = tk.Frame(app)
edit_image_frame.pack(side="right", pady=10, padx=20)

open_image_label = tk.Label(edit_image_frame, text="待加水印图片:", width=12, anchor="w")
open_image_label.grid(column=0, row=0, pady=5, padx=2)

open_image_entry = tk.Entry(edit_image_frame, width=40)
open_image_entry.grid(column=1, row=0, pady=5, padx=2)

open_image_browse_button = tk.Button(edit_image_frame, text="浏览", command=browse_open_image)
open_image_browse_button.grid(column=2, row=0, pady=5, padx=2)

# 水印图片选择
watermark_label = tk.Label(edit_image_frame, text="水印图片:", width=12, anchor="w")
watermark_label.grid(column=0, row=1, pady=5, padx=2)

watermark_entry = tk.Entry(edit_image_frame, width=40)
watermark_entry.grid(column=1, row=1, pady=5, padx=2)

watermark_browse_button = tk.Button(edit_image_frame, text="浏览", command=browse_watermark_image)
watermark_browse_button.grid(column=2, row=1, pady=5, padx=2)

# 输出图片选择
output_label = tk.Label(edit_image_frame, text="图片输出文件夹:", width=12, anchor="w")
output_label.grid(column=0, row=2, pady=5, padx=2)

output_entry = tk.Entry(edit_image_frame, width=40)
output_entry.grid(column=1, row=2, pady=5, padx=2)

output_browse_button = tk.Button(edit_image_frame, text="浏览", command=browse_output_image)
output_browse_button.grid(column=2, row=2, pady=5, padx=2)

# 水印位置选择
position_label = tk.Label(edit_image_frame, pady=5, padx=2, text="水印位置:", width=12, anchor="w")
position_label.grid(column=0, row=3)

position_var = tk.StringVar()
position_option = ttk.Combobox(
    edit_image_frame,
    textvariable=position_var,
    values=["左上", "右上", "居中", "左下", "右下"],
    width=10,
    state="readonly",
)
position_option.current(2)
position_option.grid(column=1, row=3, pady=5, padx=2, sticky="w")
position_option.bind("<<ComboboxSelected>>", on_position_change)

# 水印透明度选择
opacity_label = tk.Label(edit_image_frame, text="水印透明度:", width=12, anchor="w")
opacity_label.grid(column=0, row=4, pady=5, padx=2)

opacity_var = tk.StringVar()
opacity_option = ttk.Combobox(
    edit_image_frame,
    textvariable=opacity_var,
    values=["0%", "10%", "20%", "30%", "40%", "50%", "60%", "70%", "80%", "90%", "100%"],
    width=10,
    state="readonly",
)

# 默认选择100%
opacity_option.current(10) 
opacity_option.grid(column=1, row=4, pady=5, padx=2, sticky="w")
opacity_option.bind("<<ComboboxSelected>>", on_opacity_change)

# 水印缩放比例选择
scale_label = tk.Label(edit_image_frame, text="水印缩放比例:", width=12, anchor="w")
scale_label.grid(column=0, row=5, pady=5, padx=2)

scale_var = tk.StringVar()
scale_option = ttk.Combobox(
    edit_image_frame,
    textvariable=scale_var,
    values=["3%", "5%", "10%", "20%", "30%", "40%", "50%", "60%", "70%", "80%", "90%", "100%", "150%", "200%", "250%", "300%"],
    width=10,
    state="readonly",
)
# 默认选择100%
scale_option.current(11)
scale_option.grid(column=1, row=5, pady=5, padx=2, sticky="w")
scale_option.bind("<<ComboboxSelected>>", on_scale_change)

# 水印角度
current_tilt = tk.IntVar(value=0)
tilt_label = tk.Label(edit_image_frame, text="水印角度: ", width=12, anchor="w")
tilt_label.grid(column=0, row=6, pady=5, padx=2)
tilt_spinbox = tk.Spinbox(edit_image_frame,
                       from_=0,
                       to=359,
                       wrap=True,
                       textvariable=current_tilt,
                       )
tilt_spinbox.grid(column=1, row=6, pady=5, padx=2, sticky="w")
tilt_spinbox.bind("<ButtonRelease-1>", on_tilt_change)
tilt_spinbox.bind("<KeyRelease>", on_Release_change)

# 开始添加水印按钮
start_button = tk.Button(edit_image_frame, text="保存", command=add_watermark_process)
start_button.grid(column=0, row=7, pady=10, columnspan=2)

# 当前模块直接被执行
if __name__ == "__main__":
    # 运行主循环
    app.mainloop()