PDF去水印方法大全

前言

很多做公众号资源分享的会在PDF资源上搞一堆水印，像牛皮癣一样，很恶心，甚至有的资源上能出现两三个公众号的联系方式。今天来教大家如何去除水印，学会后至少能去除90%的水印。

注意点：

1. 本篇谈论的水印指的是脱离文件资源本身，搞各种推广的部分，因此页眉页脚部分只要是涉及推广一律当作水印去除。
2. 教程非常适合白底黑字的PDF资源，其他PDF资源可能效果并不好。

学习去除水印之前，首先了解水印出现的位置和加水印的方式。

水印出现的位置：

1. 页眉页脚处的水印。
2. 正文中文字底部的灰色半透明大文字或图案水印。
3. 正文中随机位置的水印。

添加水印的方式：

1. 使用PDF编辑器给PDF添加水印。
2. 扫描成PDF之前源文件（word，图片等）就已经添加了水印（比如word的页眉页脚，正文中间的水印；图片中的水印）

去除水印的方式：

• PDF编辑器添加的

这种添加水印的方式，使用PDF编辑器可解决，无论是页眉页脚，还是正文中间的水印，都可一键去除，比较简单。

推荐的pdf编辑器有：福昕PDF编辑器，Adobe Acrobat。

• 水印非PDF编辑器添加，源文件就携带水印的

这种水印方式去除比较困难，PDF编辑器识别不了，用编辑器一个个点更是效率低到爆炸。

这里根据水印的位置给出相应的方案：

1. 页眉和页脚位置的水印，这种可以在页眉页脚的水印处添加白色填充的矩形覆盖水印；
2. 正文底部位置的大面积灰色半透明图案或文字水印，这种可以提取水印的颜色，并将颜色变为透明色，去除效果和PDF清晰度相关。对于伪PDF（扫描图片且清晰度差）的效果不行，会有残留；也有误去除的风险。
3. 正文中随机位置的水印，这部分的水印本教程无法去除。

水印的位置和去除方式说完了，下面详细分享下去水印的工具和使用方法。

编辑器制作的水印

下载福昕PDF编辑器，版本是2024绿色破解。

安装后，在页面管理选项卡下，依次把展开水印，背景，页眉页脚这三个下拉框，点击里面的全部移除。

下载Adobe Acrobat，版本是2023便携版

安装后，点击软件右侧的编辑pdf，依次展开水印，页眉页脚这三个下拉框，点击里面的全部移除。

裁剪页面页可以，但是不推荐，可以用后面的添加矩形遮盖来解决。

上面软件的获取地址是（zapro）杂铺 ，不对软件安全性做保障，有条件可以支持下正版。

非编辑器添加的页眉页脚水印

下面展示下非编辑器添加在页眉页脚处的水印

页眉水印示例

页脚水印示例

去除方法

使用python脚本来批量绘制白色填充矩形遮盖，官网下载并安装python。

安装需要的库

pip install PyMuPDF

python脚本：

import fitz  # PyMuPDF
import tkinter as tk
from tkinter import filedialog, ttk, messagebox, simpledialog
import os

class PDFRectangleDrawer:
    def __init__(self, root):
        self.root = root
        self.root.title("PDF 矩形绘制工具")
        self.root.geometry("1000x700")
        
        # 初始化变量
        self.pdf_path = None
        self.doc = None
        self.current_page_num = 0
        self.total_pages = 0
        self.rectangles = []  # 存储所有绘制的矩形 [(page_num, rect_coords), ...]
        self.start_x = None
        self.start_y = None
        self.rect = None
        self.zoom = 1.5
        self.page_image = None  # 存储当前页面的图像对象
        
        # 创建主框架
        self.main_frame = ttk.Frame(root)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 创建顶部控制区域
        self.control_frame = ttk.Frame(self.main_frame)
        self.control_frame.pack(fill=tk.X, pady=(0, 10))
        
        # 打开PDF按钮
        self.open_btn = ttk.Button(self.control_frame, text="打开PDF", command=self.open_pdf)
        self.open_btn.pack(side=tk.LEFT, padx=5)
        
        # 页面导航区域
        self.nav_frame = ttk.Frame(self.control_frame)
        self.nav_frame.pack(side=tk.LEFT, padx=20)
        
        self.prev_btn = ttk.Button(self.nav_frame, text="上一页", command=self.prev_page, state=tk.DISABLED)
        self.prev_btn.pack(side=tk.LEFT, padx=5)
        
        self.page_label = ttk.Label(self.nav_frame, text="0/0")
        self.page_label.pack(side=tk.LEFT, padx=5)
        
        self.next_btn = ttk.Button(self.nav_frame, text="下一页", command=self.next_page, state=tk.DISABLED)
        self.next_btn.pack(side=tk.LEFT, padx=5)
        
        self.goto_btn = ttk.Button(self.nav_frame, text="跳转到", command=self.goto_page, state=tk.DISABLED)
        self.goto_btn.pack(side=tk.LEFT, padx=5)
        
        # 处理按钮
        self.process_frame = ttk.Frame(self.control_frame)
        self.process_frame.pack(side=tk.RIGHT)
        
        self.clear_btn = ttk.Button(self.process_frame, text="清除矩形", command=self.clear_rectangles, state=tk.DISABLED)
        self.clear_btn.pack(side=tk.LEFT, padx=5)
        
        self.process_btn = ttk.Button(self.process_frame, text="处理PDF", command=self.process_pdf, state=tk.DISABLED)
        self.process_btn.pack(side=tk.LEFT, padx=5)
        
        # 创建画布区域
        self.canvas_frame = ttk.Frame(self.main_frame)
        self.canvas_frame.pack(fill=tk.BOTH, expand=True)
        
        self.canvas = tk.Canvas(self.canvas_frame, bg="lightgray")
        self.h_scroll = ttk.Scrollbar(self.canvas_frame, orient=tk.HORIZONTAL, command=self.canvas.xview)
        self.v_scroll = ttk.Scrollbar(self.canvas_frame, orient=tk.VERTICAL, command=self.canvas.yview)
        
        self.canvas.configure(xscrollcommand=self.h_scroll.set, yscrollcommand=self.v_scroll.set)
        
        self.h_scroll.pack(side=tk.BOTTOM, fill=tk.X)
        self.v_scroll.pack(side=tk.RIGHT, fill=tk.Y)
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # 底部状态栏
        self.status_frame = ttk.Frame(self.main_frame)
        self.status_frame.pack(fill=tk.X, pady=(10, 0))
        
        self.status_label = ttk.Label(self.status_frame, text="就绪。请打开PDF文件...")
        self.status_label.pack(side=tk.LEFT)
        
        self.rect_count_label = ttk.Label(self.status_frame, text="矩形数量: 0")
        self.rect_count_label.pack(side=tk.RIGHT)
        
        # 页面范围选择框架
        self.range_frame = ttk.LabelFrame(self.main_frame, text="处理页面范围")
        self.range_frame.pack(fill=tk.X, pady=(10, 0))
        
        self.range_var = tk.StringVar(value="all")
        self.range_all = ttk.Radiobutton(self.range_frame, text="所有页面", variable=self.range_var, value="all")
        self.range_all.pack(side=tk.LEFT, padx=10)
        
        self.range_current = ttk.Radiobutton(self.range_frame, text="当前页面", variable=self.range_var, value="current")
        self.range_current.pack(side=tk.LEFT, padx=10)
        
        # 自定义范围按钮（替代原来的单选按钮和输入框）
        self.custom_range_btn = ttk.Button(self.range_frame, text="自定义范围", 
                                          command=self.apply_current_rectangles_to_range, 
                                          state=tk.DISABLED)
        self.custom_range_btn.pack(side=tk.LEFT, padx=10)
        
        # 绑定鼠标事件
        self.canvas.bind("<Button-1>", self.on_button_press)
        self.canvas.bind("<B1-Motion>", self.on_mouse_drag)
        self.canvas.bind("<ButtonRelease-1>", self.on_button_release)
        
        # 绑定鼠标滚轮事件用于滚动和缩放
        self.canvas.bind("<MouseWheel>", self.on_mouse_wheel_scroll)  # Windows
        self.canvas.bind("<Button-4>", self.on_mouse_wheel_scroll)  # Linux上滚
        self.canvas.bind("<Button-5>", self.on_mouse_wheel_scroll)  # Linux下滚
        self.canvas.bind("<Control-MouseWheel>", self.on_mouse_wheel_zoom)  # Windows缩放
        self.canvas.bind("<Control-Button-4>", self.on_mouse_wheel_zoom)  # Linux缩放
        self.canvas.bind("<Control-Button-5>", self.on_mouse_wheel_zoom)  # Linux缩放
        
        # 绑定窗口大小变化事件
        self.canvas.bind("<Configure>", self.on_canvas_configure)
        
    def open_pdf(self):
        """打开PDF文件"""
        pdf_path = filedialog.askopenfilename(title="选择 PDF 文件", filetypes=[("PDF 文件", "*.pdf")])
        if not pdf_path:
            return
            
        self.pdf_path = pdf_path
        self.doc = fitz.open(self.pdf_path)
        self.total_pages = len(self.doc)
        self.current_page_num = 0
        
        # 更新状态
        self.status_label.config(text=f"已加载: {os.path.basename(self.pdf_path)}")
        
        # 启用按钮
        self.prev_btn.config(state=tk.NORMAL)
        self.next_btn.config(state=tk.NORMAL)
        self.goto_btn.config(state=tk.NORMAL)
        self.clear_btn.config(state=tk.NORMAL)
        self.process_btn.config(state=tk.NORMAL)
        self.custom_range_btn.config(state=tk.NORMAL)
        
        # 加载第一页
        self.load_page(0)
        
    def load_page(self, page_num):
        """加载指定页面"""
        if not self.doc or page_num < 0 or page_num >= self.total_pages:
            return
            
        self.current_page_num = page_num
        self.page = self.doc[page_num]
        
        # 更新页面标签
        self.page_label.config(text=f"{page_num + 1}/{self.total_pages}")
        
        # 渲染页面
        self.render_page()
        
        # 绘制已有的矩形
        self.draw_existing_rectangles()
        
    def render_page(self):
        """渲染当前页面到画布"""
        # 清除画布
        self.canvas.delete("all")
        
        # 设置缩放
        mat = fitz.Matrix(self.zoom, self.zoom)
        pix = self.page.get_pixmap(matrix=mat)
        
        # 创建图像
        img_data = pix.samples
        img_mode = "RGBA" if pix.alpha else "RGB"
        img_size = (pix.width, pix.height)
        
        from PIL import Image, ImageTk
        img = Image.frombytes(img_mode, img_size, img_data)
        self.page_image = ImageTk.PhotoImage(image=img)
        
        # 计算画布中心位置
        canvas_width = self.canvas.winfo_width()
        canvas_height = self.canvas.winfo_height()
        
        # 计算图像位置，使其居中
        x_pos = max(0, (canvas_width - pix.width) // 2)
        y_pos = max(0, (canvas_height - pix.height) // 2)
        
        # 设置画布滚动区域，确保足够大以容纳图像和居中的空间
        scroll_width = max(canvas_width, pix.width + x_pos * 2)
        scroll_height = max(canvas_height, pix.height + y_pos * 2)
        self.canvas.config(scrollregion=(0, 0, scroll_width, scroll_height))
        
        # 在计算的位置显示图像
        self.canvas.create_image(x_pos, y_pos, image=self.page_image, tags="page", anchor=tk.NW)
        
        # 初始滚动位置
        if pix.width > canvas_width:
            self.canvas.xview_moveto(x_pos / scroll_width)
        else:
            self.canvas.xview_moveto(0)
            
        if pix.height > canvas_height:
            self.canvas.yview_moveto(y_pos / scroll_height)
        else:
            self.canvas.yview_moveto(0)

    def on_canvas_configure(self, event):
        """当画布大小改变时重新居中图像"""
        if hasattr(self, 'page') and self.page_image:
            # 重新渲染页面以更新居中位置
            self.render_page()
            self.draw_existing_rectangles()
        
    def draw_existing_rectangles(self):
        """在当前页面上绘制已存在的矩形"""
        for page_num, rect_coords in self.rectangles:
            if page_num == self.current_page_num:
                # 将PDF坐标转换为画布坐标
                x0, y0, x1, y1 = rect_coords
                canvas_x0 = x0 * self.zoom
                canvas_y0 = y0 * self.zoom
                canvas_x1 = x1 * self.zoom
                canvas_y1 = y1 * self.zoom
                
                # 获取图像位置偏移
                image_item = self.canvas.find_withtag("page")
                if image_item:
                    image_coords = self.canvas.coords(image_item[0])
                    if image_coords:
                        offset_x, offset_y = image_coords[0], image_coords[1]
                        
                        # 绘制矩形 - 半透明白色，考虑图像偏移
                        self.canvas.create_rectangle(
                            offset_x + canvas_x0, offset_y + canvas_y0, 
                            offset_x + canvas_x1, offset_y + canvas_y1, 
                            outline="black", width=1, fill="white", stipple="gray50", tags="rect"
                        )
    
    def prev_page(self):
        """显示上一页"""
        if self.current_page_num > 0:
            self.load_page(self.current_page_num - 1)
    
    def next_page(self):
        """显示下一页"""
        if self.current_page_num < self.total_pages - 1:
            self.load_page(self.current_page_num + 1)
    
    def goto_page(self):
        """跳转到指定页面"""
        page = simpledialog.askinteger("跳转到页面", 
                                        f"输入页码 (1-{self.total_pages}):",
                                        minvalue=1, maxvalue=self.total_pages)
        if page:
            self.load_page(page - 1)  # 转换为0索引
    
    def on_button_press(self, event):
        """鼠标按下事件"""
        if not self.doc:
            return
            
        self.start_x = self.canvas.canvasx(event.x)
        self.start_y = self.canvas.canvasy(event.y)
    
    def on_mouse_drag(self, event):
        """鼠标拖动事件"""
        if not self.doc or self.start_x is None:
            return
            
        cur_x = self.canvas.canvasx(event.x)
        cur_y = self.canvas.canvasy(event.y)
        
        # 删除之前的临时矩形
        if self.rect:
            self.canvas.delete(self.rect)
            
        # 创建新的临时矩形 - 半透明白色
        self.rect = self.canvas.create_rectangle(
            self.start_x, self.start_y, cur_x, cur_y,
            outline="black", width=1, fill="white", stipple="gray50", tags="temp_rect"
        )
    
    def on_button_release(self, event):
        """鼠标释放事件"""
        if not self.doc or self.start_x is None:
            return
            
        end_x = self.canvas.canvasx(event.x)
        end_y = self.canvas.canvasy(event.y)
        
        # 确保矩形有一定大小
        if abs(end_x - self.start_x) < 5 or abs(end_y - self.start_y) < 5:
            if self.rect:
                self.canvas.delete(self.rect)
            self.rect = None
            self.start_x = None
            self.start_y = None
            return
        
        # 获取图像位置偏移
        image_item = self.canvas.find_withtag("page")
        if not image_item:
            return
            
        image_coords = self.canvas.coords(image_item[0])
        if not image_coords:
            return
            
        offset_x, offset_y = image_coords[0], image_coords[1]
        
        # 计算矩形坐标（PDF坐标系），考虑图像偏移
        pdf_x0 = (min(self.start_x, end_x) - offset_x) / self.zoom
        pdf_y0 = (min(self.start_y, end_y) - offset_y) / self.zoom
        pdf_x1 = (max(self.start_x, end_x) - offset_x) / self.zoom
        pdf_y1 = (max(self.start_y, end_y) - offset_y) / self.zoom
        
        # 添加到矩形列表
        self.rectangles.append((self.current_page_num, (pdf_x0, pdf_y0, pdf_x1, pdf_y1)))
        
        # 更新矩形计数
        self.rect_count_label.config(text=f"矩形数量: {len(self.rectangles)}")
        
        # 清除临时矩形
        if self.rect:
            self.canvas.delete(self.rect)
        
        # 绘制永久矩形 - 半透明白色
        self.canvas.create_rectangle(
            self.start_x, self.start_y, end_x, end_y,
            outline="black", width=1, fill="white", stipple="gray50", tags="rect"
        )
        
        self.rect = None
        self.start_x = None
        self.start_y = None
        
        # 更新状态栏
        self.status_label.config(text=f"已添加白色矩形 ({pdf_x0:.1f}, {pdf_y0:.1f}) - ({pdf_x1:.1f}, {pdf_y1:.1f})")
    
    def on_mouse_wheel_scroll(self, event):
        """鼠标滚轮事件用于滚动"""
        if not self.doc:
            return
            
        # 根据不同平台处理滚轮事件
        if event.num == 4 or event.num == 5:  # Linux
            delta = -1 if event.num == 5 else 1
        else:  # Windows
            delta = event.delta // 120
        
        # 滚动画布
        self.canvas.yview_scroll(-delta, "units")
    
    def on_mouse_wheel_zoom(self, event):
        """鼠标滚轮+Ctrl事件用于缩放"""
        if not self.doc:
            return
            
        # 根据不同平台处理滚轮事件
        if event.num == 4 or event.num == 5:  # Linux
            delta = -1 if event.num == 5 else 1
        else:  # Windows
            delta = event.delta // 120
        
        # 缩放因子
        factor = 0.1 if delta > 0 else -0.1
        new_zoom = max(0.5, min(3.0, self.zoom + factor))
        
        if new_zoom != self.zoom:
            self.zoom = new_zoom
            self.render_page()
            self.draw_existing_rectangles()
            self.status_label.config(text=f"缩放: {self.zoom:.1f}x")
    
    def clear_rectangles(self):
        """清除所有矩形"""
        if not self.rectangles:
            return
            
        if messagebox.askyesno("确认", "确定要清除所有矩形吗？"):
            self.rectangles = []
            self.rect_count_label.config(text="矩形数量: 0")
            self.render_page()  # 重新渲染页面，清除所有矩形
            self.status_label.config(text="已清除所有矩形")
    
    def parse_page_range(self, range_str, max_pages):
        """解析页面范围字符串，返回页码列表"""
        pages = []
        if not range_str:
            return pages
            
        parts = range_str.split(',')
        for part in parts:
            if '-' in part:
                start, end = part.split('-')
                try:
                    start_num = int(start.strip())
                    end_num = int(end.strip())
                    if 1 <= start_num <= max_pages and 1 <= end_num <= max_pages:
                        pages.extend(range(start_num, end_num + 1))
                except ValueError:
                    messagebox.showerror("错误", f"无效的页面范围: {part}")
                    return []
            else:
                try:
                    page_num = int(part.strip())
                    if 1 <= page_num <= max_pages:
                        pages.append(page_num)
                except ValueError:
                    messagebox.showerror("错误", f"无效的页码: {part}")
                    return []
                    
        return sorted(set(pages))  # 去重并排序
    
    def process_pdf(self):
        """处理PDF，应用白色矩形"""
        if not self.doc or not self.rectangles:
            messagebox.showinfo("提示", "没有PDF文件或矩形可处理")
            return
        
        # 确定处理页面范围
        range_type = self.range_var.get()
        pages_to_process = []
        
        if range_type == "all":
            # 处理所有页面
            pages_to_process = list(range(1, self.total_pages + 1))
        elif range_type == "current":
            # 只处理当前页面
            pages_to_process = [self.current_page_num + 1]
        elif range_type == "custom":
            # 自定义范围 - 由于移除了输入框，这里直接使用存储的自定义范围
            if hasattr(self, 'custom_pages') and self.custom_pages:
                pages_to_process = self.custom_pages
            else:
                messagebox.showerror("错误", "未设置自定义页面范围")
                return
        
        # 询问保存路径
        output_pdf = filedialog.asksaveasfilename(
            title="保存修改后的 PDF 文件", 
            defaultextension=".pdf", 
            filetypes=[("PDF 文件", "*.pdf")],
            initialfile=f"{os.path.splitext(os.path.basename(self.pdf_path))[0]}_modified.pdf"
        )
        
        if not output_pdf:
            return
        
        # 创建一个新的PDF文档
        doc_out = fitz.open(self.pdf_path)
        
        # 处理页面
        processed_count = 0
        for page_idx in range(len(doc_out)):
            page_num = page_idx + 1  # 转换为1-based索引
            
            # 如果页面不在处理范围内，则跳过
            if page_num not in pages_to_process:
                continue
                
            page = doc_out[page_idx]
            
            # 应用矩形
            for rect_page_num, rect_coords in self.rectangles:
                # 如果是当前页面的矩形，或者需要应用到所有页面
                if rect_page_num == page_idx or range_type == "all":
                    # 创建矩形对象
                    rect = fitz.Rect(*rect_coords)
                    
                    # 绘制白色填充矩形
                    page.draw_rect(rect, color=(1, 1, 1), fill=(1, 1, 1))
            
            processed_count += 1
        
        # 保存修改后的PDF
        doc_out.save(output_pdf)
        doc_out.close()
        
        # 更新状态
        self.status_label.config(text=f"已处理 {processed_count} 页并保存到: {os.path.basename(output_pdf)}")
        messagebox.showinfo("处理完成", f"已成功处理 {processed_count} 页并保存到:\n{output_pdf}")

    def apply_current_rectangles_to_range(self):
        """将当前页面的矩形应用到指定的页面范围"""
        if not self.doc:
            messagebox.showinfo("提示", "请先打开PDF文件")
            return
            
        # 获取当前页面的矩形
        current_page_rectangles = []
        for page_num, rect_coords in self.rectangles:
            if page_num == self.current_page_num:
                current_page_rectangles.append(rect_coords)
        
        if not current_page_rectangles:
            messagebox.showinfo("提示", "当前页面没有绘制矩形")
            return
        
        # 弹出对话框，让用户输入要应用的页面范围
        range_str = simpledialog.askstring("应用到页面范围", 
                                       "输入要应用矩形的页面范围 (例如: 1-5,8,11-13):",
                                       initialvalue="")
        
        if not range_str:
            return
            
        pages = self.parse_page_range(range_str, self.total_pages)
        if not pages:
            return
        
        # 应用矩形到指定页面
        for page_num in pages:
            if page_num - 1 != self.current_page_num:  # 转换为0索引并排除当前页面
                for rect_coords in current_page_rectangles:
                    self.rectangles.append((page_num - 1, rect_coords))
        
        # 设置范围变量为"custom"并存储自定义页面列表
        self.range_var.set("custom")
        self.custom_pages = pages
        
        # 更新矩形计数
        self.rect_count_label.config(text=f"矩形数量: {len(self.rectangles)}")
        self.status_label.config(text=f"已将当前页面的矩形应用到 {len(pages)} 个页面")

# 创建主窗口
if __name__ == "__main__":
    root = tk.Tk()
    app = PDFRectangleDrawer(root)
    root.mainloop()

脚本使用方法：

新建文本文档，粘贴以上代码到文本文档，改后缀为py保存，双击运行。

• 运行后，点击打开pdf，选择要去除水印的pdf文件。

• pdf打开后，切换到合适的页面，框选要去除的部分

可以多次框选，框选完页眉，也可以再框选页脚部分。

框选后，默认是对所有页面框选部分添加白色填充矩形遮盖，也可以切换成，当前页，自定义范围；矩形绘制的不满意，可以清除矩形重新绘制。

• 最后点击处理pdf，选择保存处理后的位置。

处理时间很快，大概2s左右把216页pdf全部处理完成，文件大小没有太大变化。

好像Adobe Acrobat有插件可以完成类似的效果，没找到。

非编辑器添加的正文水印

水印示例

去除方法

使用python脚本对这个水印取色，把这个颜色变成透明色。这个过程会把所有pdf页面变成图片，然后再扫描成pdf，因此最后得到的文件体积非常大。（ps:不懂代码，不知道AI干了啥，我只是给出去除的方案，具体怎么写全靠AI）

脚本使用方法

安装需要的库:

pip install PyMuPDF
pip install pillow
pip install numpy

python脚本：

import fitz
import tkinter as tk
from tkinter import filedialog, ttk, messagebox
from PIL import Image, ImageTk, ImageEnhance
import numpy as np
import tempfile
import os
import threading
import webbrowser
from datetime import datetime

class PDFViewer:
    def __init__(self, root, pdf_path=None):
        self.root = root
        self.pdf_path = pdf_path
        self.selected_color = None
        self.tolerance = 30  # 默认颜色容差
        self.dpi = 300  # 默认DPI
        self.contrast = 1.2  # 默认对比度
        self.zoom = 2.0  # 默认缩放比例
        self.current_page_idx = 0  # 初始化当前页面索引
        self.preview_mode = False  # 预览模式标志
        self.original_image = None
        self.doc = None
        self.page = None
        self.pix = None
        self.image = None
        self.tk_image = None
        
        # 设置主题样式
        self.style = ttk.Style()
        self.style.theme_use('clam')  # 使用更现代的主题
        
        # 配置颜色方案
        self.bg_color = "#f0f0f0"
        self.accent_color = "#4a86e8"
        self.highlight_color = "#e8f0fe"
        
        # 设置窗口图标
        try:
            self.root.iconbitmap("icon.ico")  # 如果有图标文件的话
        except:
            pass
        
        # 创建菜单栏
        self.create_menu()
        
        # 创建主界面
        self.create_ui()
        
        # 如果提供了PDF路径，则加载PDF
        if self.pdf_path:
            self.load_pdf(self.pdf_path)
        else:
            self.show_welcome_screen()
    
    def create_menu(self):
        """创建菜单栏"""
        menubar = tk.Menu(self.root)
        
        # 文件菜单
        file_menu = tk.Menu(menubar, tearoff=0)
        file_menu.add_command(label="打开PDF", command=self.open_pdf, accelerator="Ctrl+O")
        file_menu.add_command(label="保存处理结果", command=self.save_processed_pdf, accelerator="Ctrl+S")
        file_menu.add_separator()
        file_menu.add_command(label="退出", command=self.root.quit, accelerator="Alt+F4")
        menubar.add_cascade(label="文件", menu=file_menu)
        
        # 编辑菜单
        edit_menu = tk.Menu(menubar, tearoff=0)
        edit_menu.add_command(label="重置颜色选择", command=self.reset_color_selection)
        edit_menu.add_command(label="恢复默认设置", command=self.reset_settings)
        menubar.add_cascade(label="编辑", menu=edit_menu)
        
        # 视图菜单
        view_menu = tk.Menu(menubar, tearoff=0)
        view_menu.add_command(label="放大", command=lambda: self.change_zoom_level(0.5))
        view_menu.add_command(label="缩小", command=lambda: self.change_zoom_level(-0.5))
        view_menu.add_command(label="适合窗口", command=self.fit_to_window)
        menubar.add_cascade(label="视图", menu=view_menu)
        
        # 帮助菜单
        help_menu = tk.Menu(menubar, tearoff=0)
        help_menu.add_command(label="使用说明", command=self.show_help)
        help_menu.add_command(label="关于", command=self.show_about)
        menubar.add_cascade(label="帮助", menu=help_menu)
        
        self.root.config(menu=menubar)
        
        # 绑定快捷键
        self.root.bind("<Control-o>", lambda e: self.open_pdf())
        self.root.bind("<Control-s>", lambda e: self.save_processed_pdf())
        
    def create_ui(self):
        """创建用户界面"""
        # 主框架
        self.main_frame = tk.Frame(self.root, bg=self.bg_color)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 顶部控制区域
        self.top_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        self.top_frame.pack(fill=tk.X, pady=(0, 10))
        
        # 创建页面导航区域
        self.create_page_navigation()
        
        # 创建工具栏
        self.create_toolbar()
        
        # 中间区域 - 左侧设置面板和右侧预览区域
        self.middle_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        self.middle_frame.pack(fill=tk.BOTH, expand=True)
        
        # 左侧设置面板
        self.settings_frame = tk.LabelFrame(self.middle_frame, text="设置面板", bg=self.bg_color, padx=10, pady=10)
        self.settings_frame.pack(side=tk.LEFT, fill=tk.Y, padx=(0, 10))
        
        # 创建设置控件
        self.create_settings_panel()
        
        # 右侧预览区域
        self.preview_frame = tk.LabelFrame(self.middle_frame, text="预览区域", bg=self.bg_color)
        self.preview_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
        
        # 创建画布和滚动条
        self.create_canvas()
        
        # 底部状态栏
        self.create_statusbar()
        
        # 进度条
        self.progress_var = tk.DoubleVar()
        self.progress_bar = ttk.Progressbar(self.main_frame, variable=self.progress_var, maximum=100)
        self.progress_bar.pack(fill=tk.X, pady=(10, 0))
        self.progress_bar.pack_forget()  # 默认隐藏
    
    def create_page_navigation(self):
        """创建页面导航区域"""
        self.page_frame = tk.Frame(self.top_frame, bg=self.bg_color)
        self.page_frame.pack(side=tk.LEFT, fill=tk.Y)
        
        # 页面导航按钮
        self.nav_frame = tk.Frame(self.page_frame, bg=self.bg_color)
        self.nav_frame.pack(fill=tk.X)
        
        self.first_page_btn = ttk.Button(self.nav_frame, text="<<", width=3, command=self.goto_first_page)
        self.first_page_btn.pack(side=tk.LEFT, padx=2)
        
        self.prev_page_btn = ttk.Button(self.nav_frame, text="<", width=3, command=self.goto_prev_page)
        self.prev_page_btn.pack(side=tk.LEFT, padx=2)
        
        # 页面选择
        self.page_var = tk.StringVar(value="1")
        self.page_entry = ttk.Entry(self.nav_frame, textvariable=self.page_var, width=5)
        self.page_entry.pack(side=tk.LEFT, padx=2)
        self.page_entry.bind("<Return>", self.change_page_from_entry)
        
        self.page_count_label = ttk.Label(self.nav_frame, text="/0", background=self.bg_color)
        self.page_count_label.pack(side=tk.LEFT, padx=2)
        
        self.next_page_btn = ttk.Button(self.nav_frame, text=">", width=3, command=self.goto_next_page)
        self.next_page_btn.pack(side=tk.LEFT, padx=2)
        
        self.last_page_btn = ttk.Button(self.nav_frame, text=">>", width=3, command=self.goto_last_page)
        self.last_page_btn.pack(side=tk.LEFT, padx=2)
    
    def create_toolbar(self):
        """创建工具栏"""
        self.toolbar_frame = tk.Frame(self.top_frame, bg=self.bg_color)
        self.toolbar_frame.pack(side=tk.RIGHT, fill=tk.Y)
        
        # 放大/缩小按钮
        self.zoom_frame = tk.Frame(self.toolbar_frame, bg=self.bg_color)
        self.zoom_frame.pack(side=tk.RIGHT, padx=10)
        
        self.zoom_out_btn = ttk.Button(self.zoom_frame, text="-", width=3, command=lambda: self.change_zoom_level(-0.5))
        self.zoom_out_btn.pack(side=tk.LEFT, padx=2)
        
        self.zoom_var = tk.StringVar(value="200%")
        self.zoom_label = ttk.Label(self.zoom_frame, textvariable=self.zoom_var, background=self.bg_color, width=6)
        self.zoom_label.pack(side=tk.LEFT, padx=2)
        
        self.zoom_in_btn = ttk.Button(self.zoom_frame, text="+", width=3, command=lambda: self.change_zoom_level(0.5))
        self.zoom_in_btn.pack(side=tk.LEFT, padx=2)
        
        # 预览/处理按钮
        self.action_frame = tk.Frame(self.toolbar_frame, bg=self.bg_color)
        self.action_frame.pack(side=tk.RIGHT, padx=10)
        
        self.preview_button = ttk.Button(self.action_frame, text="预览效果", command=self.preview_watermark_removal)
        self.preview_button.pack(side=tk.LEFT, padx=5)
        self.preview_button.config(state=tk.DISABLED)
        
        self.process_button = ttk.Button(self.action_frame, text="处理全部", command=self.process_pdf)
        self.process_button.pack(side=tk.LEFT, padx=5)
        self.process_button.config(state=tk.DISABLED)
    
    def create_settings_panel(self):
        """创建设置面板"""
        # 颜色选择区域
        self.color_frame = tk.LabelFrame(self.settings_frame, text="水印颜色", bg=self.bg_color, padx=5, pady=5)
        self.color_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.color_info_label = ttk.Label(self.color_frame, text="点击图像选择水印颜色", background=self.bg_color)
        self.color_info_label.pack(anchor=tk.W, pady=5)
        
        self.color_display = tk.Frame(self.color_frame, width=50, height=25, bd=1, relief=tk.SUNKEN, bg="white")
        self.color_display.pack(fill=tk.X, pady=5)
        
        self.color_value_label = ttk.Label(self.color_frame, text="RGB: ---", background=self.bg_color)
        self.color_value_label.pack(anchor=tk.W, pady=5)
        
        # 颜色容差设置
        self.tolerance_frame = tk.LabelFrame(self.settings_frame, text="颜色容差", bg=self.bg_color, padx=5, pady=5)
        self.tolerance_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.tolerance_var = tk.IntVar(value=30)
        self.tolerance_slider = ttk.Scale(self.tolerance_frame, from_=5, to=100, 
                                         variable=self.tolerance_var, 
                                         orient=tk.HORIZONTAL)
        self.tolerance_slider.pack(fill=tk.X, pady=5)
        
        self.tolerance_value_frame = tk.Frame(self.tolerance_frame, bg=self.bg_color)
        self.tolerance_value_frame.pack(fill=tk.X)
        
        ttk.Label(self.tolerance_value_frame, text="小", background=self.bg_color).pack(side=tk.LEFT)
        ttk.Label(self.tolerance_value_frame, textvariable=self.tolerance_var, background=self.bg_color, width=5).pack(side=tk.LEFT, expand=True)
        ttk.Label(self.tolerance_value_frame, text="大", background=self.bg_color).pack(side=tk.RIGHT)
        
        # 图像质量设置
        self.quality_frame = tk.LabelFrame(self.settings_frame, text="图像质量", bg=self.bg_color, padx=5, pady=5)
        self.quality_frame.pack(fill=tk.X, pady=(0, 10))
        
        # DPI设置
        self.dpi_frame = tk.Frame(self.quality_frame, bg=self.bg_color)
        self.dpi_frame.pack(fill=tk.X, pady=5)
        
        ttk.Label(self.dpi_frame, text="DPI:", background=self.bg_color).pack(side=tk.LEFT)
        
        self.dpi_var = tk.IntVar(value=300)
        self.dpi_combo = ttk.Combobox(self.dpi_frame, textvariable=self.dpi_var, 
                                     values=["150", "200", "300", "400", "600"],
                                     width=5, state="readonly")
        self.dpi_combo.pack(side=tk.RIGHT)
        
        # 对比度设置
        self.contrast_frame = tk.Frame(self.quality_frame, bg=self.bg_color)
        self.contrast_frame.pack(fill=tk.X, pady=5)
        
        ttk.Label(self.contrast_frame, text="对比度:", background=self.bg_color).pack(side=tk.LEFT)
        
        self.contrast_var = tk.DoubleVar(value=1.2)
        self.contrast_slider = ttk.Scale(self.contrast_frame, from_=1.0, to=2.0, 
                                        variable=self.contrast_var, 
                                        orient=tk.HORIZONTAL)
        self.contrast_slider.pack(fill=tk.X, pady=5)
        
        self.contrast_value_frame = tk.Frame(self.contrast_frame, bg=self.bg_color)
        self.contrast_value_frame.pack(fill=tk.X)
        
        ttk.Label(self.contrast_value_frame, text="低", background=self.bg_color).pack(side=tk.LEFT)
        self.contrast_value_label = ttk.Label(self.contrast_value_frame, text="1.2", background=self.bg_color, width=5)
        self.contrast_value_label.pack(side=tk.LEFT, expand=True)
        ttk.Label(self.contrast_value_frame, text="高", background=self.bg_color).pack(side=tk.RIGHT)
        
        # 绑定事件
        self.tolerance_slider.bind("<ButtonRelease-1>", self.update_tolerance)
        self.contrast_slider.bind("<ButtonRelease-1>", self.update_contrast)
    
    def create_canvas(self):
        """创建画布和滚动条"""
        self.canvas_container = tk.Frame(self.preview_frame)
        self.canvas_container.pack(fill=tk.BOTH, expand=True)
        
        self.canvas = tk.Canvas(self.canvas_container, bg="white", cursor="cross")
        self.h_scroll = ttk.Scrollbar(self.canvas_container, orient=tk.HORIZONTAL, command=self.canvas.xview)
        self.v_scroll = ttk.Scrollbar(self.canvas_container, orient=tk.VERTICAL, command=self.canvas.yview)
        
        self.canvas.configure(xscrollcommand=self.h_scroll.set, yscrollcommand=self.v_scroll.set)
        
        self.h_scroll.pack(side=tk.BOTTOM, fill=tk.X)
        self.v_scroll.pack(side=tk.RIGHT, fill=tk.Y)
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # 绑定事件
        self.canvas.bind("<Button-1>", self.get_color)
        self.canvas.bind("<MouseWheel>", self.mouse_wheel)  # Windows滚轮
        self.canvas.bind("<Button-4>", self.mouse_wheel)  # Linux上滚
        self.canvas.bind("<Button-5>", self.mouse_wheel)  # Linux下滚
    
    def create_statusbar(self):
        """创建状态栏"""
        self.status_frame = tk.Frame(self.main_frame, bg=self.bg_color)
        self.status_frame.pack(fill=tk.X, pady=(10, 0))
        
        self.status_var = tk.StringVar(value="请打开PDF文件")
        self.status_label = ttk.Label(self.status_frame, textvariable=self.status_var, 
                                    anchor=tk.W, relief=tk.SUNKEN, padding=(5, 2))
        self.status_label.pack(fill=tk.X)
    
    def show_welcome_screen(self):
        """显示欢迎界面"""
        welcome_frame = tk.Frame(self.canvas, bg="white", bd=0)
        welcome_window = self.canvas.create_window(400, 300, window=welcome_frame, anchor=tk.CENTER)
        
        tk.Label(welcome_frame, text="PDF水印去除工具", font=("Arial", 24, "bold"), bg="white").pack(pady=10)
        tk.Label(welcome_frame, text="一键去除PDF文档中的水印", font=("Arial", 14), bg="white").pack(pady=5)
        
        button_frame = tk.Frame(welcome_frame, bg="white")
        button_frame.pack(pady=20)
        
        ttk.Button(button_frame, text="打开PDF文件", command=self.open_pdf, width=20).pack(side=tk.LEFT, padx=10)
        
        # 调整画布大小
        self.canvas.config(scrollregion=(0, 0, 800, 600))
    
    def open_pdf(self):
        """打开PDF文件"""
        file_path = filedialog.askopenfilename(filetypes=[("PDF Files", "*.pdf")])
        if file_path:
            self.load_pdf(file_path)
    
    def load_pdf(self, pdf_path):
        """加载PDF文件"""
        try:
            # 关闭之前打开的文档
            if self.doc:
                self.doc.close()
            
            self.pdf_path = pdf_path
            self.doc = fitz.open(self.pdf_path)
            
            # 更新页面计数
            self.page_count_label.config(text=f"/{len(self.doc)}")
            
            # 重置页面索引
            self.current_page_idx = 0
            self.page_var.set("1")
            
            # 加载第一页
            self.load_page()
            
            # 更新状态栏
            filename = os.path.basename(self.pdf_path)
            self.status_var.set(f"已加载: {filename} - 点击图像选择水印颜色")
            
            # 重置颜色选择
            self.reset_color_selection()
            
            # 启用导航按钮
            self.update_navigation_buttons()
        except Exception as e:
            messagebox.showerror("错误", f"无法加载PDF文件:\n{str(e)}")
    
    def load_page(self):
        """加载当前页面"""
        if not self.doc:
            return
            
        self.page = self.doc[self.current_page_idx]
        self.update_image()
        self.preview_mode = False
    
    def update_image(self):
        """更新图像"""
        if not self.page:
            return
            
        self.mat = fitz.Matrix(self.zoom, self.zoom)
        self.pix = self.page.get_pixmap(matrix=self.mat)
        self.image = Image.frombytes("RGB", [self.pix.width, self.pix.height], self.pix.samples)
        self.original_image = self.image.copy()  # 保存原始图像用于预览
        self.tk_image = ImageTk.PhotoImage(self.image)
        self.update_canvas()
    
    def update_canvas(self):
        """更新画布内容"""
        self.canvas.delete("all")
        if self.tk_image:
            self.canvas.config(scrollregion=(0, 0, self.pix.width, self.pix.height))
            self.canvas_image = self.canvas.create_image(0, 0, anchor=tk.NW, image=self.tk_image)
    
    def change_page_from_entry(self, event=None):
        """从输入框更改页面"""
        try:
            page_num = int(self.page_var.get())
            if 1 <= page_num <= len(self.doc):
                self.current_page_idx = page_num - 1
                self.preview_mode = False
                self.load_page()
                self.update_navigation_buttons()
            else:
                self.page_var.set(str(self.current_page_idx + 1))
        except:
            self.page_var.set(str(self.current_page_idx + 1))
    
    def goto_first_page(self):
        """跳转到第一页"""
        if self.doc and self.current_page_idx > 0:
            self.current_page_idx = 0
            self.page_var.set("1")
            self.preview_mode = False
            self.load_page()
            self.update_navigation_buttons()
    
    def goto_prev_page(self):
        """跳转到上一页"""
        if self.doc and self.current_page_idx > 0:
            self.current_page_idx -= 1
            self.page_var.set(str(self.current_page_idx + 1))
            self.preview_mode = False
            self.load_page()
            self.update_navigation_buttons()
    
    def goto_next_page(self):
        """跳转到下一页"""
        if self.doc and self.current_page_idx < len(self.doc) - 1:
            self.current_page_idx += 1
            self.page_var.set(str(self.current_page_idx + 1))
            self.preview_mode = False
            self.load_page()
            self.update_navigation_buttons()
    
    def goto_last_page(self):
        """跳转到最后一页"""
        if self.doc and self.current_page_idx < len(self.doc) - 1:
            self.current_page_idx = len(self.doc) - 1
            self.page_var.set(str(self.current_page_idx + 1))
            self.preview_mode = False
            self.load_page()
            self.update_navigation_buttons()
    
    def update_navigation_buttons(self):
        """更新导航按钮状态"""
        if not self.doc:
            state = tk.DISABLED
        else:
            # 第一页和上一页按钮
            if self.current_page_idx <= 0:
                self.first_page_btn.config(state=tk.DISABLED)
                self.prev_page_btn.config(state=tk.DISABLED)
            else:
                self.first_page_btn.config(state=tk.NORMAL)
                self.prev_page_btn.config(state=tk.NORMAL)
            
            # 下一页和最后一页按钮
            if self.current_page_idx >= len(self.doc) - 1:
                self.next_page_btn.config(state=tk.DISABLED)
                self.last_page_btn.config(state=tk.DISABLED)
            else:
                self.next_page_btn.config(state=tk.NORMAL)
                self.last_page_btn.config(state=tk.NORMAL)
    
    def change_zoom_level(self, delta):
        """更改缩放级别"""
        new_zoom = self.zoom + delta
        if 0.5 <= new_zoom <= 5.0:
            self.zoom = new_zoom
            self.zoom_var.set(f"{int(self.zoom * 100)}%")
            self.update_image()
    
    def fit_to_window(self):
        """适应窗口大小"""
        if not self.page:
            return
            
        # 获取画布尺寸
        canvas_width = self.canvas.winfo_width()
        canvas_height = self.canvas.winfo_height()
        
        # 获取页面尺寸
        page_width = self.page.rect.width
        page_height = self.page.rect.height
        
        # 计算合适的缩放比例
        width_ratio = canvas_width / page_width
        height_ratio = canvas_height / page_height
        
        # 使用较小的比例，确保整个页面可见
        self.zoom = min(width_ratio, height_ratio) * 0.9
        self.zoom_var.set(f"{int(self.zoom * 100)}%")
        
        self.update_image()
    
    def mouse_wheel(self, event):
        """鼠标滚轮事件处理"""
        # 确定滚动方向
        if event.num == 4 or event.delta > 0:  # 向上滚动
            self.canvas.yview_scroll(-1, "units")
        elif event.num == 5 or event.delta < 0:  # 向下滚动
            self.canvas.yview_scroll(1, "units")
    
    def get_color(self, event):
        """用户点击获取颜色"""
        if not self.doc:
            return
            
        if self.preview_mode:
            # 如果在预览模式，切换回原始模式
            self.preview_mode = False
            self.image = self.original_image.copy()
            self.tk_image = ImageTk.PhotoImage(self.image)
            self.update_canvas()
            if self.selected_color:
                self.status_var.set(f"已选颜色: RGB{self.selected_color}, 容差: {self.tolerance}")
            return
            
        x, y = self.canvas.canvasx(event.x), self.canvas.canvasy(event.y)

        # 确保坐标在图像范围内
        if 0 <= x < self.pix.width and 0 <= y < self.pix.height:
            color = self.image.getpixel((x, y))  # 获取 RGB 颜色
            self.selected_color = color
            
            # 更新状态栏
            self.status_var.set(f"已选颜色: RGB{color}, 容差: {self.tolerance}")
            
            # 更新颜色显示
            self.color_display.config(bg=f"#{color[0]:02x}{color[1]:02x}{color[2]:02x}")
            self.color_value_label.config(text=f"RGB: {color}")
            
            # 启用预览和处理按钮
            self.preview_button.config(state=tk.NORMAL)
            self.process_button.config(state=tk.NORMAL)
    
    def update_tolerance(self, event):
        """更新颜色容差"""
        self.tolerance = self.tolerance_var.get()
        if self.selected_color:
            self.status_var.set(f"已选颜色: RGB{self.selected_color}, 容差: {self.tolerance}")
            self.preview_button.config(state=tk.NORMAL)
    
    def update_contrast(self, event):
        """更新对比度设置"""
        self.contrast = self.contrast_var.get()
        self.contrast_value_label.config(text=f"{self.contrast:.1f}")
        if self.selected_color:
            self.preview_button.config(state=tk.NORMAL)
    
    def preview_watermark_removal(self):
        """预览水印去除效果"""
        if not self.selected_color or not self.doc:
            return
            
        self.status_var.set("正在生成预览...")
        self.root.update()
        
        try:
            # 使用当前图像进行预览
            img_data = np.array(self.original_image)
            
            # 计算与目标颜色的距离，去水印
            mask = np.sqrt(np.sum((img_data - np.array(self.selected_color)) ** 2, axis=-1)) < self.tolerance
            img_data[mask] = [255, 255, 255]  # 变为白色

            # 转换回 PIL 图片
            img_no_watermark = Image.fromarray(img_data)
            img_no_watermark = ImageEnhance.Contrast(img_no_watermark).enhance(self.contrast)  # 提高对比度
            
            # 更新图像
            self.image = img_no_watermark
            self.tk_image = ImageTk.PhotoImage(self.image)
            self.update_canvas()
            
            self.preview_mode = True
            self.status_var.set("预览模式 - 点击图像返回原始视图")
        except Exception as e:
            messagebox.showerror("预览错误", f"生成预览时出错:\n{str(e)}")
    
    def process_pdf(self):
        """处理整个PDF文件"""
        if not self.selected_color or not self.doc:
            return
            
        # 询问保存位置
        output_pdf = filedialog.asksaveasfilename(
            defaultextension=".pdf",
            filetypes=[("PDF Files", "*.pdf")],
            initialfile=self._get_default_output_filename()
        )
        
        if not output_pdf:
            return
            
        # 显示进度条
        self.progress_bar.pack(fill=tk.X, pady=(10, 0))
        self.status_var.set("正在处理PDF...")
        self.root.update()
        
        # 禁用界面元素
        self._set_ui_state(tk.DISABLED)
        
        # 在单独的线程中处理PDF
        processing_thread = threading.Thread(
            target=self._process_pdf_thread,
            args=(output_pdf,)
        )
        processing_thread.daemon = True
        processing_thread.start()
    
    def _process_pdf_thread(self, output_pdf):
        """在单独的线程中处理PDF"""
        try:
            self._remove_watermark(output_pdf)
            
            # 在主线程中更新UI
            self.root.after(0, lambda: self._processing_complete(True, output_pdf))
        except Exception as e:
            # 在主线程中显示错误
            self.root.after(0, lambda: self._processing_complete(False, str(e)))
    
    def _remove_watermark(self, output_pdf):
        """去除PDF中的水印"""
        new_doc = fitz.open()
        total_pages = len(self.doc)
        
        # 计算基于DPI的缩放因子
        scale_factor = self.dpi_var.get() / 72.0  # PDF默认是72 DPI
        
        for page_num in range(total_pages):
            # 更新进度
            progress = (page_num / total_pages) * 100
            self.root.after(0, lambda p=progress: self.progress_var.set(p))
            self.root.after(0, lambda p=page_num, t=total_pages: 
                           self.status_var.set(f"正在处理 {p+1}/{t} 页..."))
            
            page = self.doc[page_num]
            pix = page.get_pixmap(matrix=fitz.Matrix(scale_factor, scale_factor))
            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)

            # 转换为 numpy 数组
            img_data = np.array(img)

            # 计算与目标颜色的距离，去水印
            mask = np.sqrt(np.sum((img_data - np.array(self.selected_color)) ** 2, axis=-1)) < self.tolerance
            img_data[mask] = [255, 255, 255]  # 变为白色

            # 转换回 PIL 图片
            img_no_watermark = Image.fromarray(img_data)
            img_no_watermark = ImageEnhance.Contrast(img_no_watermark).enhance(self.contrast)  # 提高对比度

            # 保存为临时文件
            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
                temp_file_path = temp_file.name
                img_no_watermark.save(temp_file_path, dpi=(self.dpi_var.get(), self.dpi_var.get()))

                # 插入图像
                new_page = new_doc.new_page(width=page.rect.width, height=page.rect.height)
                new_page.insert_image(page.rect, filename=temp_file_path)
                
                # 删除临时文件
                try:
                    os.unlink(temp_file_path)
                except:
                    pass

        # 保存去水印后的 PDF
        new_doc.save(output_pdf)
        new_doc.close()
    
    def _processing_complete(self, success, result):
        """处理完成后的回调"""
        # 隐藏进度条
        self.progress_bar.pack_forget()
        
        # 启用界面元素
        self._set_ui_state(tk.NORMAL)
        
        if success:
            self.status_var.set(f"处理完成，已保存为: {os.path.basename(result)}")
            messagebox.showinfo("处理完成", f"PDF水印去除完成，已保存为:\n{result}")
            
            # 询问是否打开处理后的文件
            if messagebox.askyesno("打开文件", "是否打开处理后的文件?"):
                try:
                    if os.name == 'nt':  # Windows
                        os.startfile(result)
                    else:  # macOS 和 Linux
                        opener = 'open' if sys.platform == 'darwin' else 'xdg-open'
                        subprocess.call([opener, result])
                except:
                    messagebox.showinfo("提示", "无法自动打开文件，请手动打开。")
        else:
            self.status_var.set(f"处理出错: {result}")
            messagebox.showerror("处理错误", f"处理出错:\n{result}")
    
    def _set_ui_state(self, state):
        """设置UI元素状态"""
        # 禁用/启用各种按钮和控件
        self.preview_button.config(state=state)
        self.process_button.config(state=state)
        self.page_entry.config(state=state)
        self.dpi_combo.config(state="readonly" if state == tk.NORMAL else tk.DISABLED)
        self.tolerance_slider.config(state=state)
        self.contrast_slider.config(state=state)
        self.first_page_btn.config(state=state)
        self.prev_page_btn.config(state=state)
        self.next_page_btn.config(state=state)
        self.last_page_btn.config(state=state)
        self.zoom_in_btn.config(state=state)
        self.zoom_out_btn.config(state=state)
    
    def _get_default_output_filename(self):
        """获取默认的输出文件名"""
        if not self.pdf_path:
            return "output.pdf"
            
        base_name = os.path.basename(self.pdf_path)
        name_without_ext = os.path.splitext(base_name)[0]
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        return f"{name_without_ext}_无水印_{timestamp}.pdf"
    
    def reset_color_selection(self):
        """重置颜色选择"""
        self.selected_color = None
        self.color_display.config(bg="white")
        self.color_value_label.config(text="RGB: ---")
        self.preview_button.config(state=tk.DISABLED)
        self.process_button.config(state=tk.DISABLED)
        self.status_var.set("请点击图像选择水印颜色")
    
    def reset_settings(self):
        """恢复默认设置"""
        self.tolerance_var.set(30)
        self.dpi_var.set(300)
        self.contrast_var.set(1.2)
        self.zoom = 2.0
        self.zoom_var.set("200%")
        
        self.tolerance = 30
        self.dpi = 300
        self.contrast = 1.2
        
        self.contrast_value_label.config(text="1.2")
        
        if self.page:
            self.update_image()
    
    def save_processed_pdf(self):
        """保存处理后的PDF"""
        if self.selected_color and self.doc:
            self.process_pdf()
        else:
            messagebox.showinfo("提示", "请先选择水印颜色")
    
    def show_help(self):
        """显示帮助信息"""
        help_text = """
使用说明:

1. 打开PDF文件: 点击"文件 > 打开PDF"或使用Ctrl+O快捷键。

2. 选择水印颜色: 在预览区域点击水印部分，选择水印的颜色。

3. 调整设置:
   - 颜色容差: 调整可识别为水印的颜色范围
   - DPI: 设置输出质量，更高的DPI意味着更清晰的结果
   - 对比度: 调整去水印后的对比度

4. 预览效果: 点击"预览效果"按钮查看当前页面的去水印效果。

5. 处理全部: 点击"处理全部"按钮处理整个PDF文档。

6. 保存结果: 处理完成后，选择保存位置。

提示: 在预览模式下，点击图像可返回原始视图。
        """
        messagebox.showinfo("使用说明", help_text)
    
    def show_about(self):
        """显示关于信息"""
        about_text = """
PDF水印去除工具

版本: 1.0.0

功能: 一键去除PDF文档中的水印

技术支持: example@example.com

© 2023 All Rights Reserved
        """
        messagebox.showinfo("关于", about_text)

def main():
    # 创建主窗口
    root = tk.Tk()
    root.title("PDF水印去除工具")
    root.geometry("1200x800")
    
    # 创建应用
    app = PDFViewer(root)
    
    # 启动主循环
    root.mainloop()

if __name__ == "__main__":
    main()

新建文本文档，粘贴以上代码到文本文档，改后缀为py保存，双击运行。

• 运行后点击打开pdf

• 左键对水印部分进行取色

• 点击预览效果

左侧的颜色容差和图像质量看着调整（注意：图像质量越大，处理时间越长，文件体积越大）

最后点击处理全部，选择保存位置，等待处理完成

底部会有进度条，1s一页大概

216页的pdf，源文件大小是103兆，处理后3.93g，有点夸张，不过效果还好。

非编辑器添加的正文随机水印

水印示例

类似这种水印，插在正文中间，每页的位置是随机的。

对于这种水印，可以尝试下面的PdfCommander工具。

PDFCommander工具

PDFCommander可以去除99.9%的PDF水印，上手难度极大，需要了解PDF结构信息，但是会用后处理的效果非常好。

https://www.52pojie.cn/thread-1943717-1-1.html