图片和PDF 加水印去水印

图片和PDF 加水印去水印

• 前要
• • 1. 图片加水印
  • • 1.1 方法1
    • 1.2 方法2
  • 2. 去水印
  • 3. pdf加水印
  • 4. pdf 去水印

前要

网上查了很多资料, 汇总了几个不错的代码, 顺便做个笔记

1. 图片加水印

1.1 方法1

简单方便, 后也好处理

# -*- coding:utf-8 -*-
import os
from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw


def watermark_Image(img_path, output_path):
    img = Image.open(img_path)
    draw = ImageDraw.Draw(img)

    # 图片水印
    # # 打开水印图片
    # watermark = Image.open('1.png')
    # # 计算水印图片大小
    # wm_width, wm_height = watermark.size
    # # 计算原图大小
    # img_width, img_height = img.size
    # wm_width = int(wm_width * 1.5)
    # wm_height = int(wm_height * 1.5)
    # watermark = watermark.resize((wm_width, wm_height))
    # # 添加水印
    # img.paste(watermark, (5, 5), watermark)

    # 字体水印
    text = "CSDN"
    # 设置字体、字体大小等等
    font = ImageFont.truetype('arial.ttf', 33)
    # 添加水印
    draw.text((50, 50), text, font=font,  fill=(255, 255, 255))
    # 保存图片
    img.save(output_path)


def run(in_path):
    out_path = './img_watermark'
    # 带水印图片路径
    if not os.path.exists(out_path):
        os.makedirs(out_path)

    file_ls = os.listdir(in_path)
    for file in file_ls:
        img_path = './{}/{}'.format(in_path, file)
        output_path = img_path.replace(in_path, out_path)
        try:
            watermark_Image(img_path, output_path)
            print(file, '完成！')
        except Exception as e:
            print(img_path, e)
        break


if __name__ == '__main__':
    run('./img_data')

1.2 方法2

太复杂, 而且后面清洗水印不好清除

import os
import sys
import argparse
from PIL import Image, ImageDraw, ImageFont, ImageEnhance


def read_origin_photo(photo_path, photo_angle=0):
    """
    获取图像内容与尺寸

    photo_path：图片路径
    photo_angle: 图片旋转角度
    """
    origin_photo = Image.open(photo_path)
    origin_photo = origin_photo.convert('RGBA')
    origin_photo = origin_photo.rotate(photo_angle, expand=True)
    h, w = origin_photo.size
    return origin_photo, h, w


# def get_color(text_color):
#     r = int(text_color[1:3], base=16)
#     g = int(text_color[3:5], base=16)
#     b = int(text_color[5:7], base=16)
#     return r, g, b


def make_text_picture(h, w, text, font_path, font_size=40, angle=-45, color=(0, 0, 0)):
    """
    制作水印图片

    h: 原图高度
    w: 原图宽度
    font_path：字体文件路径
    font_size：字体大小
    angle：字体旋转角度
    color：字体颜色
    """
    text_pic = Image.new('RGBA', (4 * h, 4 * w), (255, 255, 255, 255))
    fnt = ImageFont.truetype('arial.ttf', size=font_size)

    text_d = ImageDraw.Draw(text_pic)

    # a, b 分别控制水印的列间距和行间距，默认为字体的2倍列距，4倍行距
    a, b = 2, 4
    for x in range(10, text_pic.size[0] - 10, a * font_size * len(text)):
        for y in range(10, text_pic.size[1] - 10, b * font_size):
            text_d.multiline_text((x, y), text, fill=color, font=fnt)

    # 旋转水印
    text_pic = text_pic.rotate(angle)
    # 截取水印部分图片
    text_pic = text_pic.crop((h, w, 3 * h, 3 * w))
    # text_pic.show()
    return text_pic


def combine(origin_photo, text_pic, alpha=0.2, out_name='out.jpg'):
    """
    为图片添加水印并保存
    origin_photo: 原图内容
    text_pic: 要添加的水印图片
    alpha：水印的不透明度
    out_name: 输出图片的文件名
    """
    # 合并水印图片和原图
    text_pic = text_pic.resize(origin_photo.size)
    out = Image.blend(origin_photo, text_pic, alpha)
    out = out.convert('RGB')
    # 增强图片对比度
    enhance = ImageEnhance.Contrast(out)
    out = enhance.enhance(1.0 / (1 - alpha))
    out_path = os.path.join('./img_no_watermark/', out_name)
    out.save(out_path)
    out.show()


if __name__ == '__main__':
    # 获取cmd命令参数, 弊端:太复杂, 后面可以改成字典
    parser = argparse.ArgumentParser()
    parser.add_argument('-p', dest='path', default='./img_data/e7a88f27-dc2c-11ee-8e27-508140236042.jpg', help='图片路径，如：1.jpg或./images/1.jpg')
    parser.add_argument('-t', dest='text', default='Python', help="要添加的水印内容")
    parser.add_argument('--photo_angle', dest='photo_angle', default=0,
                        help='原图片旋转角度，默认为0，不进行旋转')
    parser.add_argument('--new_image_name', dest='new_image_name', default=None,
                        help='输出图片的名称， 默认为"原图片名_with_watermark.jpg", 图片保存在out_images目录下')
    # parser.add_argument('--font_path', dest='font_path', default=r"./fonts/STSONG.TTF",
    #                     help='要使用的字体路径，如 STSONG.TTF，windows可在C:\Windows\Fonts查找字体')
    parser.add_argument('--text_angle', dest='text_angle', default=-45,
                        help='水印的旋转角度，0为水平，-90位从上向下垂直, 90为从下向上垂直，默认-45')
    parser.add_argument('--text_color', dest='text_color', default='#000000',
                        help="水印颜色，默认#000000（黑色）")
    parser.add_argument('--text_size', dest='text_size',
                        default=40, help='水印字体的大小， 默认40')
    parser.add_argument('--text_alpha', dest='text_alpha',
                        default=0.2, help='水印的不透明度，建议0.2~0.3，默认0.2')
    args = parser.parse_args()
    # args 其实就是一个另类的自带你
    args.path = './img_data/8d9337c7-dcf9-11ee-b5dc-508140236042.jpg'
    photo_path = args.path
    print(photo_path)
    text = args.text
    if not photo_path or not text:
        print('必须指定图片路径和水印文字')
        sys.exit(-1)

    photo_angle = int(args.photo_angle)
    font_path = ''
    text_size = int(args.text_size)
    text_angle = int(args.text_angle)

    origin_photo, h, w = read_origin_photo(photo_path, photo_angle)
    text_pic = make_text_picture(h, w, text, font_path,
                                 font_size=text_size, angle=text_angle, color=args.text_color)
    new_image_name = args.new_image_name
    photo_name = os.path.split(photo_path)[-1].split('.')[0]  # 获取图片名称
    if new_image_name is None:
        new_image_name = photo_name + '_with_watermark.jpg'
    combine(origin_photo, text_pic, alpha=float(args.text_alpha),
            out_name=new_image_name)

2. 去水印

找了好多去水印代码,只有这个效果不错,但是代码需要水印模板来确定水印位置, 当然如果水印少且位置固定可以不用(例如1.1), 2.2就不展示了, 基本没变化

原理就是通过模板找到相同形状图案位置,然后根据旁边像素点进行补充

水印模板

1.1 图片去水印效果

# coding=utf-8
import os
import cv2
import numpy as np

# 膨胀算法 Kernel
_DILATE_KERNEL = np.array([[0, 0, 1, 0, 0],
                           [0, 0, 1, 0, 0],
                           [1, 1, 1, 1, 1],
                           [0, 0, 1, 0, 0],
                           [0, 0, 1, 0, 0]], dtype=np.uint8)


class WatermarkRemover(object):
    """"
    去除图片中的水印(Remove Watermark)
    """

    def __init__(self, verbose=True):
        self.verbose = verbose
        self.watermark_template_gray_img = None
        self.watermark_template_mask_img = None
        self.watermark_template_h = 0
        self.watermark_template_w = 0

    def load_watermark_template(self, watermark_template_filename):
        """
        加载水印模板，以便后面批量处理去除水印
        :param watermark_template_filename:
        :return:
        """
        self.generate_template_gray_and_mask(watermark_template_filename)

    def dilate(self, img):
        """
        对图片进行膨胀计算
        :param img:
        :return:
        """
        dilated = cv2.dilate(img, _DILATE_KERNEL)
        return dilated

    def generate_template_gray_and_mask(self, watermark_template_filename):
        """
        处理水印模板，生成对应的检索位图和掩码位图
        检索位图
            即处理后的灰度图，去除了非文字部分

        :param watermark_template_filename: 水印模板图片文件名称
        :return: x1, y1, x2, y2
        """

        # 水印模板原图
        img = cv2.imread(watermark_template_filename)

        # 灰度图、掩码图
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        _, mask = cv2.threshold(gray, 0, 255, cv2.THRESH_TOZERO + cv2.THRESH_OTSU)
        _, mask = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)

        mask = self.dilate(mask)  # 使得掩码膨胀一圈，以免留下边缘没有被修复
        #mask = self.dilate(mask)  # 使得掩码膨胀一圈，以免留下边缘没有被修复

        # 水印模板原图去除非文字部分
        img = cv2.bitwise_and(img, img, mask=mask)

        # 后面修图时需要用到三个通道
        mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)

        self.watermark_template_gray_img = gray
        self.watermark_template_mask_img = mask

        self.watermark_template_h = img.shape[0]
        self.watermark_template_w = img.shape[1]

        # cv2.imwrite('watermark-template-gray.jpg', gray)
        # cv2.imwrite('watermark-template-mask.jpg', mask)

        return gray, mask

    def find_watermark(self, filename):
        """
        从原图中寻找水印位置
        :param filename:
        :return: x1, y1, x2, y2
        """
        # Load the images in gray scale
        gray_img = cv2.imread(filename, 0)
        return self.find_watermark_from_gray(gray_img, self.watermark_template_gray_img)

    def find_watermark_from_gray(self, gray_img, watermark_template_gray_img):
        """
        从原图的灰度图中寻找水印位置
        :param gray_img: 原图的灰度图
        :param watermark_template_gray_img: 水印模板的灰度图
        :return: x1, y1, x2, y2
        """
        # Load the images in gray scale

        method = cv2.TM_CCOEFF
        # Apply template Matching
        res = cv2.matchTemplate(gray_img, watermark_template_gray_img, method)
        min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)
        # If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
        if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
            x, y = min_loc
        else:
            x, y = max_loc

        return x, y, x + self.watermark_template_w, y + self.watermark_template_h

    def remove_watermark_raw(self, img, watermark_template_gray_img, watermark_template_mask_img):
        """
        去除图片中的水印
        :param img: 待去除水印图片位图
        :param watermark_template_gray_img: 水印模板的灰度图片位图，用于确定水印位置
        :param watermark_template_mask_img: 水印模板的掩码图片位图，用于修复原始图片
        :return: 去除水印后的图片位图
        """
        # 寻找水印位置
        # img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # x1, y1, x2, y2 = self.find_watermark_from_gray(img_gray, watermark_template_gray_img)
        
        # 水印位置固定
        x1, y1, x2, y2 = 50, 55, 170, 80
        # 制作原图的水印位置遮板
        mask = np.zeros(img.shape, np.uint8)
        watermark_template_mask_img = cv2.cvtColor(watermark_template_gray_img, cv2.COLOR_GRAY2BGR)
        # print(self.watermark_template_w, self.watermark_template_h)
        
        # 水印文章固定用这个
        mask[y1:y1 + self.watermark_template_h, x1:x1 + self.watermark_template_w] = watermark_template_mask_img
        # 不固定用这个
        # mask[y1:y2, x1:x2] = watermark_template_mask_img
        mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)

        # 用遮板进行图片修复，使用 TELEA 算法
        dst = cv2.inpaint(img, mask, 5, cv2.INPAINT_TELEA)
        # cv2.imwrite('dst.jpg', dst)

        return dst

    def remove_watermark(self, filename, output_filename=None):
        """
        去除图片中的水印
        :param filename: 待去除水印图片文件名称
        :param output_filename: 去除水印图片后的输出文件名称
        :return: 去除水印后的图片位图
        """
        # 读取原图
        img = cv2.imread(filename)

        dst = self.remove_watermark_raw(img,
                                        self.watermark_template_gray_img,
                                        self.watermark_template_mask_img
                                        )

        if output_filename is not None:
            cv2.imwrite(output_filename, dst)
        return dst


def run(in_path):
    # 水印图片路径
    watermark_template_filename = './watermark.png'
    remover = WatermarkRemover()
    remover.load_watermark_template(watermark_template_filename)

    out_path = './img_no_watermark'
    if not os.path.exists(out_path):
        os.makedirs(out_path)

    file_ls = os.listdir(in_path)
    for file in file_ls:
        in_img_path = r'{}/{}'.format(in_path, file)
        out_img_path = r'{}/{}'.format(out_path, file)
        try:
            remover.remove_watermark(in_img_path, out_img_path)
            print('{} 完成！'.format(file))
        except Exception as e:
            print(e, in_img_path)

if __name__ == '__main__':
    run('./img_watermark')

3. pdf加水印

原理就是两个pdf合并到一块

代码会生成一个水印.pdf

执行代码效果

import os
from PyPDF2 import PdfReader, PdfWriter
from reportlab.lib.units import cm
from reportlab.pdfgen import canvas


def create_watermark(content):
    """水印信息"""
    # 默认大小为21cm*29.7cm
    file_name = "watermark.pdf"
    c = canvas.Canvas(file_name, pagesize=(30*cm, 30*cm))
    # 移动坐标原点(坐标系左下为(0,0))
    c.translate(10*cm, 5*cm)

    # 设置字体
    c.setFont("Helvetica", 30)
    # 指定描边的颜色
    c.setStrokeColorRGB(0, 1, 0)
    # 指定填充颜色
    c.setFillColorRGB(255, 0, 0)
    # 旋转45度,坐标系被旋转
    c.rotate(30)
    # 指定填充颜色
    c.setFillColorRGB(255, 0, 0, 0.1)
    # 设置透明度,1为不透明
    # c.setFillAlpha(0.1)
    # 画几个文本,注意坐标系旋转的影响
    for i in range(5):
        for j in range(10):
            a=10*(i-1)
            b=5*(j-2)
            c.drawString(a*cm, b*cm, content)
            c.setFillAlpha(0.1)
    # 关闭并保存pdf文件
    c.save()
    return file_name


def add_watermark(pdf_file_in, pdf_file_mark, pdf_file_out):
    """把水印添加到pdf中"""
    pdf_output = PdfWriter()
    input_stream = open(pdf_file_in, 'rb')
    pdf_input = PdfReader(input_stream, strict=False)

    # 获取PDF文件的页数
    pageNum = len(pdf_input.pages)

    # 读入水印pdf文件
    pdf_watermark = PdfReader(open(pdf_file_mark, 'rb'), strict=False)
    # 给每一页打水印
    for i in range(pageNum):
        page = pdf_input._get_page(i)
        page.merge_page(pdf_watermark._get_page(0))
        page.compress_content_streams()  # 压缩内容
        pdf_output.add_page(page)
    pdf_output.write(open(pdf_file_out, 'wb'))


def run(path):
    # 生成水印
    pdf_file_mark = create_watermark('CSDN')

    out_path = './pdf_watermark'
    if not os.path.exists(out_path):
        os.makedirs(out_path)
    file_ls = os.listdir(path)
    for file in file_ls:
        pdf_file_in = f'{path}/{file}'
        pdf_file_out = f'./{out_path}/{file}'
        try:
            add_watermark(pdf_file_in, pdf_file_mark, pdf_file_out)
            print(pdf_file_out, '完成！')
        except Exception as e:
            print(pdf_file_in, e)
        break

if __name__ == '__main__':
    run('./pdf_data')

4. pdf 去水印

原理就是把pdf转成一张张图片, 因为水印一般都是浅色且透明,所以根据水印色差对图片整体色差进行调整, 从而去除水印

水印 RGB颜色 越高越透明, 所以需要注意别写太死, 留点空间, rgb 是 230 写成 210
例如:

效果图:

import os
import shutil

import cv2
import numpy as np
import fitz
from fpdf import FPDF
from PIL import Image
import tempfile

# 定义A4纸张在300 DPI下的像素尺寸（宽度和高度）
A4_SIZE_PX_300DPI = (2480, 3508)


# 图像去除水印函数
def remove_watermark(image_path):
    img = cv2.imread(image_path)
    #  水印RGB颜色, 不要写太准, 估个差值(例如230, 改成210), 而且这三个数需要一致
    lower_hsv = np.array([210, 210, 210])
    upper_hsv = np.array([255, 255, 255])
    mask = cv2.inRange(img, lower_hsv, upper_hsv)
    mask = cv2.GaussianBlur(mask, (1, 1), 0)
    img[mask == 255] = [255, 255, 255]
    cv2.imwrite(image_path, img)


# 将PDF转换为图片，并保存到指定目录

def pdf_to_images(pdf_path, output_folder):
    images = []
    doc = fitz.open(pdf_path)
    for page_num in range(doc.page_count):
        page = doc[page_num]
        # 设置分辨率为300 DPI
        pix = page.get_pixmap(matrix=fitz.Matrix(300 / 72, 300 / 72))
        image_path = os.path.join(output_folder, f"page_{page_num + 1}.png")
        pix.save(image_path)
        images.append(image_path)
        # 去除每张图片的水印
        remove_watermark(image_path)
    return images


def images_to_pdf(image_paths, output_path):
    pdf_writer = FPDF(unit='pt', format='A4')

    # 定义A4纸张在300 DPI下的尺寸（宽度和高度）
    A4_SIZE_MM = (210, 297)
    A4_SIZE_PX_300DPI = (A4_SIZE_MM[0] * 300 / 25.4, A4_SIZE_MM[1] * 300 / 25.4)

    for image_path in image_paths:
        with Image.open(image_path) as img:
            width, height = img.size

            # 计算图像是否需要缩放以适应A4纸张，并保持长宽比
            ratio = min(A4_SIZE_PX_300DPI[0] / width, A4_SIZE_PX_300DPI[1] / height)

            # 缩放图像以适应A4纸张，并保持长宽比
            img_resized = img.resize((int(width * ratio), int(height * ratio)), resample=Image.LANCZOS)

            # 创建临时文件并写入图片数据
            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
                img_resized.save(temp_file.name, format='PNG')

            # 添加一页，注意已经按300DPI处理了图片大小
            pdf_writer.add_page()

            # 使用临时文件路径添加图像到PDF，尺寸应基于已调整为300DPI分辨率的图片
            pdf_writer.image(temp_file.name, x=0, y=0, w=pdf_writer.w, h=pdf_writer.h)

    # 清理临时文件
    for image_path in image_paths:
        _, temp_filename = os.path.split(image_path)
        if os.path.exists(temp_filename):
            os.remove(temp_filename)

    pdf_writer.output(output_path)


def run(path):
    out_path = './pdf_no_watermark'
    if not os.path.exists(out_path):
        os.makedirs(out_path)
    file_ls = os.listdir(path)
    for file in file_ls:
        pdf_file_in = f'{path}/{file}'
        pdf_file_out = f'{out_path}/{file}'

        output_folder = './output_images'
        os.makedirs(output_folder, exist_ok=True)  # 创建输出目录（如果不存在）

        try:
            image_paths = pdf_to_images(pdf_file_in, output_folder)
            images_to_pdf(image_paths, pdf_file_out)
            print(pdf_file_out)
        except Exception as e:
            print(pdf_file_in, e)

        shutil.rmtree(output_folder)


if __name__ == '__main__':
    run('./pdf_watermark')

最后还是感谢很多大佬的分享, 我只是把他们的代码做了个汇总