标签： Python

比较笨的方法，用来提取PPT课程视频画面，并生成对应的PPT，代码检测黑屏但没有检测白屏，没有检测重复画面（因为有些人讲课会来回翻PPT），因此还有优化空间。内存占用会逐渐增多，不过测试没有出现崩溃的情况。

PS：做完发现可以直接问讲课人要PPT原件，我，，，

import cv2
import os
import numpy as np
from pptx import Presentation
from pptx.util import Inches
from skimage.metrics import structural_similarity as ssim
import tkinter as tk
from tkinter import filedialog, messagebox

# 选择视频和输出目录
def select_video_and_output():
    video_path = filedialog.askopenfilename(title="选择视频文件", filetypes=[("MP4 files", "*.mp4")])
    if not video_path:
        messagebox.showwarning("选择视频", "未选择视频文件")
        return None, None
    
    output_dir = filedialog.askdirectory(title="选择输出目录")
    if not output_dir:
        messagebox.showwarning("选择输出目录", "未选择输出目录")
        return None, None

    pptx_path = os.path.join(output_dir, "output_presentation.pptx")
    return video_path, pptx_path

# 处理视频并生成 PPT
def process_video_to_ppt(video_path, pptx_path):
    os.makedirs("ppt_images", exist_ok=True)
    
    cap = cv2.VideoCapture(video_path)
    _, prev_frame = cap.read()
    prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)

    frame_count = 0
    slide_count = 0
    images = []
    similarity_threshold = 0.95  # 提高 SSIM 阈值，减少相似图片
    brightness_threshold = 10  # 黑屏检测（平均亮度 < 10 认为是黑屏）

    def process_frame(frame):
        """ 计算 SSIM 相似度，判断是否保存该帧 """
        nonlocal prev_gray, slide_count
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        score = ssim(prev_gray, gray)

        # 计算平均亮度，过滤黑屏
        avg_brightness = np.mean(gray)
        if avg_brightness < brightness_threshold:
            return  # 跳过黑屏帧

        if score < similarity_threshold:  
            img_path = os.path.join("ppt_images", f"slide_{slide_count}.jpg")

            # 确保不同的幻灯片才保存
            if len(images) == 0 or images[-1] != img_path:  
                cv2.imwrite(img_path, frame)
                images.append(img_path)
                slide_count += 1
                prev_gray = gray  # 只在确认变化时更新参考帧

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        # 仅每隔 15 帧处理一次
        if frame_count % 15 == 0:
            process_frame(frame)

        frame_count += 1

    cap.release()
    # cv2.destroyAllWindows()

    # 创建 PPT
    prs = Presentation()
    for img in images:
        slide = prs.slides.add_slide(prs.slide_layouts[5])  # 空白幻灯片
        left, top, width, height = Inches(0), Inches(0), Inches(10), Inches(7.5)
        slide.shapes.add_picture(img, left, top, width, height)

    prs.save(pptx_path)
    messagebox.showinfo("完成", f"PPTX 生成完成: {pptx_path}")

# 主函数
def main():
    root = tk.Tk()
    root.withdraw()  # 隐藏主窗口
    video_path, pptx_path = select_video_and_output()
    if video_path and pptx_path:
        process_video_to_ppt(video_path, pptx_path)

if __name__ == "__main__":
    main()

此前写了个使用cwebp、gif2webp的脚本，但是由于cwebp目前在win的元数据提取存在问题，因此我们可以使用已经支持exif提取和写入的exiftool进行最后一步的转换，这样我们的图片压缩、转码都在官方库得以实现。

前置条件：

cwebp、gif2webp、exiftool三个组件都注册到系统环境变量。python则使用pil库用于分辨率获取。

实现效果：

使用pil库对分辨率进行获取，但是不介入压缩过程，因为cwebp目前没法获取图片分辨率，使用pil库进行是否执行resize的判断。

使用cwebp处理静态png、jpg，使用gif2webp处理gif图，启用mt多线程，压缩质量85，resize到2560最长、宽边，exiftool采用”-overwrite_original”来避免生成两个图片。

测试效果：

该图片原图7M多，压缩质量选择85，可能由于细节较为丰富，压缩到WebP大小仍为1M左右，还是比较大，不过细节保留充分，同时保留了EXIF信息。

import tkinter as tk
from tkinter import filedialog, messagebox
import os
import subprocess
from PIL import Image

def validate_file(input_path):
    input_path = os.path.abspath(input_path)
    if not os.path.exists(input_path):
        raise FileNotFoundError(f"文件 {input_path} 不存在，请检查路径。")
    return input_path

def get_resized_dimensions(width, height, max_size):
    if width > height:
        new_width = max_size
        new_height = int((new_width / width) * height)
    else:
        new_height = max_size
        new_width = int((new_height / height) * width)
    return new_width, new_height

def convert_image(input_path, output_path, new_width=None, new_height=None):
    try:
        file_extension = os.path.splitext(input_path)[1].lower()
        if file_extension == ".gif":
            command = ["gif2webp","mt", input_path, "-o", output_path]
        else:
            if new_width and new_height:
                command = ["cwebp","mt", "-q", "85", "-resize", str(new_width), str(new_height), input_path, "-o", output_path]
            else:
                command = ["cwebp","mt", "-q", "85", input_path, "-o", output_path]
        subprocess.run(command, check=True)
    except subprocess.CalledProcessError as e:
        raise RuntimeError(f"转换工具运行出错: {e}")

def embed_exif(input_path, output_path):
    try:
        command = ["exiftool", "-overwrite_original", "-tagsfromfile", input_path, "-all:all", output_path]
        subprocess.run(command, check=True)
    except subprocess.CalledProcessError as e:
        raise RuntimeError(f"EXIF 数据嵌入失败: {e}")

def convert_to_webp(input_path, max_size=2560):
    try:
        # 验证文件路径
        input_path = validate_file(input_path)
        output_path = os.path.splitext(input_path)[0] + ".webp"

        # 使用 PIL 获取图像分辨率
        with Image.open(input_path) as img:
            width, height = img.size
            if width <= max_size and height <= max_size:
                convert_image(input_path, output_path)
            else:
                new_width, new_height = get_resized_dimensions(width, height, max_size)
                convert_image(input_path, output_path, new_width, new_height)

        # 嵌入 EXIF 数据
        embed_exif(input_path, output_path)

        return f"图片已转换并保存为 {output_path}"

    except (subprocess.CalledProcessError, FileNotFoundError) as e:
        return str(e)
    except Exception as e:
        return f"处理文件时发生错误: {e}"

def select_files():
    file_paths = filedialog.askopenfilenames(
        title="选择图片文件",
        filetypes=[("*所有图片格式", "*.jpg;*.jpeg;*.png;*.gif"),
                   ("JPEG 图片", "*.jpg;*.jpeg"),
                   ("PNG 图片", "*.png"),
                   ("GIF 图片", "*.gif")]
    )
    if file_paths:
        for path in file_paths:
            file_listbox.insert(tk.END, path)

def convert_and_save_batch():
    files = file_listbox.get(0, tk.END)
    if not files:
        messagebox.showerror("错误", "请选择至少一个图片文件！")
        return

    results = [convert_to_webp(file_path) for file_path in files]
    messagebox.showinfo("完成", "\n".join(results))

def clear_list():
    file_listbox.delete(0, tk.END)

root = tk.Tk()
root.title("批量图片转换为 WebP 工具")
root.geometry("600x400")

frame = tk.Frame(root)
frame.pack(pady=10, padx=10, fill=tk.BOTH, expand=True)

scrollbar = tk.Scrollbar(frame, orient=tk.VERTICAL)
file_listbox = tk.Listbox(frame, selectmode=tk.EXTENDED, yscrollcommand=scrollbar.set)
scrollbar.config(command=file_listbox.yview)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
file_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

button_frame = tk.Frame(root)
button_frame.pack(pady=10)

select_button = tk.Button(button_frame, text="选择文件", command=select_files, width=15)
select_button.grid(row=0, column=0, padx=5)

clear_button = tk.Button(button_frame, text="清空列表", command=clear_list, width=15)
clear_button.grid(row=0, column=1, padx=5)

convert_button = tk.Button(button_frame, text="批量转换", command=convert_and_save_batch, width=15)
convert_button.grid(row=0, column=2, padx=5)

root.mainloop()

此前的代码使用了Pillow库集成的库，这次使用WebP官方库，对GIF、PNG的处理也比较友好。需要添加WebP的库到系统环境变量后使用。

功能实现：

代码使用cwebp、gif2webp两种方式转换不同的格式图片，使用库本身的压缩分辨率方法，压缩图片到2560最长、宽。

对于gif，该代码可以实现对原图动态的保持，此前使用pillow库则可以设定gif的持续或者最后一帧静帧。

遗憾：

没有能够传递exif，win平台中cwebp压根没法有效传递exif信息，显示——Warning: only ICC profile extraction is currently supported on this platform!元数据只有ICC才能支持传递，所以只依靠cwebp是没法很好在win中进行转换的。

这个问题采用exiftool进行了解决，下篇文章可以看到。

import tkinter as tk
from tkinter import filedialog, messagebox
import os
import subprocess
from PIL import Image

def validate_file(input_path):
    input_path = os.path.abspath(input_path)
    if not os.path.exists(input_path):
        raise FileNotFoundError(f"文件 {input_path} 不存在，请检查路径。")
    return input_path

def get_resized_dimensions(width, height, max_size):
    if width > height:
        new_width = max_size
        new_height = int((new_width / width) * height)
    else:
        new_height = max_size
        new_width = int((new_height / height) * width)
    return new_width, new_height

# 使用 cwebp 或 gif2webp 进行转换
def convert_image(input_path, output_path, new_width=None, new_height=None, cwebp_metadata="none", gif2webp_metadata="none"):
    try:
        file_extension = os.path.splitext(input_path)[1].lower()
        if file_extension == ".gif":
            command = ["gif2webp", "-metadata", gif2webp_metadata, "-mt", input_path, "-o", output_path]
        else:
            if new_width and new_height:
                command = ["cwebp", "-q", "85", "-resize", str(new_width), str(new_height), "-metadata", cwebp_metadata, "-mt", input_path, "-o", output_path]
            else:
                command = ["cwebp", "-q", "85", "-metadata", cwebp_metadata, "-mt", input_path, "-o", output_path]
        subprocess.run(command, check=True)
    except subprocess.CalledProcessError as e:
        raise RuntimeError(f"转换工具运行出错: {e}")

def convert_to_webp(input_path, max_size=2560, cwebp_metadata="none", gif2webp_metadata="none"):
    try:
        # 验证文件路径
        input_path = validate_file(input_path)
        output_path = os.path.splitext(input_path)[0] + ".webp"

        # 使用 PIL 获取图像分辨率
        with Image.open(input_path) as img:
            width, height = img.size
            if width <= max_size and height <= max_size:
                convert_image(input_path, output_path, cwebp_metadata=cwebp_metadata, gif2webp_metadata=gif2webp_metadata)
            else:
                new_width, new_height = get_resized_dimensions(width, height, max_size)
                convert_image(input_path, output_path, new_width, new_height, cwebp_metadata=cwebp_metadata, gif2webp_metadata=gif2webp_metadata)

        return f"图片已转换并保存为 {output_path}"

    except (subprocess.CalledProcessError, FileNotFoundError) as e:
        return str(e)
    except Exception as e:
        return f"处理文件时发生错误: {e}"

def select_files():
    file_paths = filedialog.askopenfilenames(
        title="选择图片文件",
        filetypes=[("*所有图片格式", "*.jpg;*.jpeg;*.png;*.gif"),
                   ("JPEG 图片", "*.jpg;*.jpeg"),
                   ("PNG 图片", "*.png"),
                   ("GIF 图片", "*.gif")]
    )
    if file_paths:
        for path in file_paths:
            file_listbox.insert(tk.END, path)

def convert_and_save_batch():
    files = file_listbox.get(0, tk.END)
    if not files:
        messagebox.showerror("错误", "请选择至少一个图片文件！")
        return

    cwebp_metadata = "exif"  # 设置cwebp要复制的元数据类型为exif
    gif2webp_metadata = "xmp"  # 设置gif2webp要复制的元数据类型为xmp
    results = [convert_to_webp(file_path, cwebp_metadata=cwebp_metadata, gif2webp_metadata=gif2webp_metadata) for file_path in files]
    messagebox.showinfo("完成", "\n".join(results))

def clear_list():
    file_listbox.delete(0, tk.END)

# 创建主窗口
root = tk.Tk()
root.title("批量图片转换为 WebP 工具")
root.geometry("600x400")

frame = tk.Frame(root)
frame.pack(pady=10, padx=10, fill=tk.BOTH, expand=True)

scrollbar = tk.Scrollbar(frame, orient=tk.VERTICAL)
file_listbox = tk.Listbox(frame, selectmode=tk.EXTENDED, yscrollcommand=scrollbar.set)
scrollbar.config(command=file_listbox.yview)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
file_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

button_frame = tk.Frame(root)
button_frame.pack(pady=10)

select_button = tk.Button(button_frame, text="选择文件", command=select_files, width=15)
select_button.grid(row=0, column=0, padx=5)

clear_button = tk.Button(button_frame, text="清空列表", command=clear_list, width=15)
clear_button.grid(row=0, column=1, padx=5)

convert_button = tk.Button(button_frame, text="批量转换", command=convert_and_save_batch, width=15)
convert_button.grid(row=0, column=2, padx=5)

root.mainloop()

一些网页通过加载Js来保护页面元素，当我们突破Js得到本地页面时，可以使用BS4库对页面进行分析，提取对应的元素来综合有价值的内容。

示例代码：

import requests
from bs4 import BeautifulSoup
import pandas as pd

# 发送请求并获取网页内容
url = 'your_local_or_online_page_url'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

# 定义一个空的列表来存储提取的数据
data = []

# 遍历页面中的项目列表，假设项目数据都在某个父元素中
projects = soup.find_all('tr', class_='project-id')  # 根据实际情况修改选择器

# 提取每个项目的各项数据
for project in projects:
    # 获取项目ID
    project_id = project.find('td', class_='project-id-class').get_text(strip=True)  # 修改为实际选择器
    
    # 将提取的数据添加到列表中
    data.append([project_id]) # 按实际修改

# 创建 DataFrame 并保存为 Excel
df = pd.DataFrame(data, columns=['ID']) # 按实际修改
df.to_excel('projects_data.xlsx', index=False)

print("Data has been successfully extracted and saved to 'projects_data.xlsx'.")

主要用到了BS4库。

示意代码：

from bs4 import BeautifulSoup

# 假设有一个HTML文档
html_doc = """
<html>
  <head><title>Example Page</title></head>
  <body>
    <p class="title"><b>Sample Page</b></p>
    <p class="story">This is a test story. <a href="http://example.com/1" class="link">link1</a> <a href="http://example.com/2" class="link">link2</a></p>
    <p class="story">Another test story.</p>
  </body>
</html>
"""

# 使用 BeautifulSoup 解析 HTML 文档
soup = BeautifulSoup(html_doc, 'html.parser')

# 提取<title>标签的内容
title = soup.title.string
print(f"Title: {title}")

# 提取所有的链接（<a> 标签）
links = soup.find_all('a')
for link in links:
    print(f"Link text: {link.string}, URL: {link['href']}")

# 查找特定类的<p>标签
story_paragraphs = soup.find_all('p', class_='story')
for p in story_paragraphs:
    print(f"Story paragraph: {p.get_text()}")

为了制作一些高大上的风格化 PPT，有时我们需要很多客户的反白色LOGO，以符合当下的一些设计潮流。

目前常用的做法是在 PPT中对图片本身进行亮度调整，可以理解为一键过曝，但是这对于一些本身就含有白色的图片不适用，也无法处理JPG的图片，更没法快速将反白的图片进行批量保存，以便存储成库，在其他场景继续使用。

因此使用脚本可以防止原来的白色部分混成一团，预先对原LOGO白色区域进行透明化，然后对其他颜色区域反白。

这个脚本目前适用于我的工作环境，包含一些问题，例如如果原来的图标包含白色文字，这样会将其透明化，因此还需按照使用情况进行调整。

后续考虑加入对JPG进行处理的过程，原理上是对白色部分预先透明度处理，然后后续步骤基本一致，不过使用JPG作为LOGO的客户较少，该功能并不急迫。若要实现该功能，可能需要使用OCR对文字部分预先识别处理，流程上麻烦不少，不过由于wechat-ocr的强大功能，应该也可以稳定呈现，wechat-ocr此前有过一些实践，效果出众，推荐大家使用。

此外脚本尚未测试灰色部分是否会有问题，目前感觉应该会有问题，若使用中有其他问题会随时更新。

import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk
import random
import string
class ImageProcessor(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Logo Image Processor")
        self.geometry("600x600")
        self.image_path = None
        self.images = []  # 用于存储多个图像
        self.image_label = tk.Label(self)
        self.image_label.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)
        
        # 设置拖放区域
        self.drop_area = tk.Label(self, text="拖动PNG图片到此区域", relief="solid", width=30, height=4)
        self.drop_area.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)
        self.drop_area.bind("<Enter>", self.on_drag_enter)
        self.drop_area.bind("<Leave>", self.on_drag_leave)
        self.drop_area.bind("<ButtonRelease-1>", self.on_drop)
        # 添加处理按钮
        self.process_button = tk.Button(self, text="处理图片并保存", command=self.process_images)
        self.process_button.pack(pady=10)
    def on_drag_enter(self, event):
        self.drop_area.config(bg="lightblue")
    def on_drag_leave(self, event):
        self.drop_area.config(bg="white")
    def on_drop(self, event):
        file_paths = filedialog.askopenfilenames(filetypes=[("PNG files", "*.png")])
        if file_paths:
            self.load_images(file_paths)
    def load_images(self, paths):
        self.images = []  # 清空当前图像列表
        for path in paths:
            image = Image.open(path).convert("RGBA")  # 确保加载为RGBA格式以处理透明度
            self.images.append((path, image))  # 存储图像及其路径
        if self.images:
            self.display_image(self.images[0][1])  # 显示第一张图片
    def display_image(self, image):
        image_tk = ImageTk.PhotoImage(image)
        self.image_label.config(image=image_tk)
        self.image_label.image = image_tk
    def process_images(self):
        if self.images:
            for original_path, image in self.images:
                # 获取图像的每个像素
                pixels = image.load()
                width, height = image.size
                
                for x in range(width):
                    for y in range(height):
                        r, g, b, a = pixels[x, y]
                        
                        # 将白色部分透明化
                        if r == 255 and g == 255 and b == 255:
                            pixels[x, y] = (255, 255, 255, 0)  # 将白色变为透明
                        elif a != 0:  # 如果是非透明区域
                            # 将所有非透明区域变为纯白色
                            pixels[x, y] = (255, 255, 255, a)  # 变为白色，保持原透明度
                
                # 生成随机字符并保存处理后的图像
                random_suffix = ''.join(random.choices(string.ascii_letters + string.digits, k=6))
                output_path = f"processed_logo_{random_suffix}.png"
                image.save(output_path)
                print(f"处理后的LOGO图片已保存为 {output_path}")
                
            # 更新显示处理后的图片（显示第一张图像）
            self.display_image(self.images[0][1])
if __name__ == "__main__":
    app = ImageProcessor()
    app.mainloop()

此外，还可以对JPG进行处理：

注意保证输入图片的分辨率，其平滑操作对分辨率会有一定的损失。

import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageFilter
import random
import string
import os
class ImageProcessor(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Logo Image Processor")
        self.geometry("400x200")  # 设置主窗口大小
        self.image_path = None
        self.images = []  # 用于存储多个图像
        self.processed_images = []  # 用于存储处理后图像路径
        # 设置拖放区域
        self.drop_area = tk.Label(self, text="拖动PNG或JPG图片到此区域", relief="solid", width=30, height=4)
        self.drop_area.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)
        self.drop_area.bind("<Enter>", self.on_drag_enter)
        self.drop_area.bind("<Leave>", self.on_drag_leave)
        self.drop_area.bind("<ButtonRelease-1>", self.on_drop)
        # 添加处理按钮
        self.process_button = tk.Button(self, text="处理图片并保存", command=self.process_images)
        self.process_button.pack(pady=10)
        # 添加选择输出路径按钮
        self.output_dir = None
        self.select_output_button = tk.Button(self, text="选择保存路径", command=self.select_output_dir)
        self.select_output_button.pack(pady=5)
    def on_drag_enter(self, event):
        self.drop_area.config(bg="lightblue")
    def on_drag_leave(self, event):
        self.drop_area.config(bg="white")
    def on_drop(self, event):
        file_paths = filedialog.askopenfilenames(filetypes=[("Image files", "*.png *.jpg *.jpeg")])
        if file_paths:
            self.load_images(file_paths)
    def load_images(self, paths):
        self.images = []  # 清空当前图像列表
        for path in paths:
            try:
                image = Image.open(path)
                # 将JPG图像转换为支持透明度的RGBA格式
                if image.mode != "RGBA":
                    image = image.convert("RGBA")
                self.images.append((path, image))  # 存储图像及其路径
            except Exception as e:
                print(f"无法加载图像 {path}: {e}")
                messagebox.showerror("错误", f"无法加载图像 {path}")
                
    def select_output_dir(self):
        self.output_dir = filedialog.askdirectory()
        if self.output_dir:
            print(f"选择的输出目录是: {self.output_dir}")
        
    def process_images(self):
        if not self.images:
            messagebox.showwarning("警告", "请先加载图片")
            return
        
        if not self.output_dir:
            messagebox.showwarning("警告", "请先选择保存路径")
            return
        for original_path, image in self.images:
            pixels = image.load()
            width, height = image.size
            
            for x in range(width):
                for y in range(height):
                    r, g, b, a = pixels[x, y]
                    
                    # 将接近白色的区域透明化，设置阈值范围 (240, 240, 240) 到 (255, 255, 255)
                    if r >= 240 and g >= 240 and b >= 240:
                        pixels[x, y] = (255, 255, 255, 0)  # 将接近白色的部分变为透明
                    elif a != 0:  # 如果是非透明区域
                        # 将所有非透明区域变为纯白色
                        pixels[x, y] = (255, 255, 255, a)  # 变为白色，保持原透明度
            # 对图像进行边缘平滑处理，减少杂色
            image = image.filter(ImageFilter.GaussianBlur(radius=2))
            
            # 生成随机字符并保存处理后的图像
            random_suffix = ''.join(random.choices(string.ascii_letters + string.digits, k=6))
            output_path = os.path.join(self.output_dir, f"processed_logo_{random_suffix}.png")
            image.save(output_path)
            print(f"处理后的LOGO图片已保存为 {output_path}")
            self.processed_images.append(output_path)
if __name__ == "__main__":
    app = ImageProcessor()
    app.mainloop()

输入两个图片，进行合成，自动在1图标记1986，2图标记2024，图片对齐，保持没有空白，程序自动复位。

import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image, ImageTk, ImageDraw, ImageFont

class ImageCombinerApp:
    def __init__(self, root):
        self.root = root
        self.root.title("图片合成器")
        
        # 初始化存储的图片路径
        self.first_image_path = None
        self.second_image_path = None
        
        # 创建界面组件
        self.create_widgets()
    
    def create_widgets(self):
        # 第一张图片上传按钮
        self.btn_upload_first = tk.Button(self.root, text="上传第一张图片", command=self.upload_first_image)
        self.btn_upload_first.grid(row=0, column=0, padx=10, pady=10)
        
        # 第二张图片上传按钮
        self.btn_upload_second = tk.Button(self.root, text="上传第二张图片", command=self.upload_second_image)
        self.btn_upload_second.grid(row=0, column=1, padx=10, pady=10)
        
        # 合成按钮
        self.btn_combine = tk.Button(self.root, text="合成图片", command=self.combine_images)
        self.btn_combine.grid(row=1, column=0, columnspan=2, padx=10, pady=10)
        
        # 显示图片区域
        self.image_panel = tk.Label(self.root)
        self.image_panel.grid(row=2, column=0, columnspan=2, padx=10, pady=10)

    def upload_first_image(self):
        file_path = filedialog.askopenfilename(title="选择第一张图片", filetypes=[("Image files", "*.jpg;*.jpeg;*.png")])
        if file_path:
            self.first_image_path = file_path
            messagebox.showinfo("图片上传", "第一张图片已成功上传。")
    
    def upload_second_image(self):
        file_path = filedialog.askopenfilename(title="选择第二张图片", filetypes=[("Image files", "*.jpg;*.jpeg;*.png")])
        if file_path:
            self.second_image_path = file_path
            messagebox.showinfo("图片上传", "第二张图片已成功上传。")
    
    def combine_images(self):
        if not self.first_image_path or not self.second_image_path:
            messagebox.showerror("错误", "请先上传两张图片。")
            return
        
        img1 = Image.open(self.first_image_path)
        img2 = Image.open(self.second_image_path)

        # 检查并缩放图像，如果图像的尺寸超过指定最大尺寸
        img1 = self.resize_image(img1)
        img2 = self.resize_image(img2)

        # 统一宽度，按比例调整高度
        img1, img2 = self.resize_images_to_same_width(img1, img2)

        # 添加年份文字到图片
        self.add_text_to_image(img1, "1986")
        self.add_text_to_image(img2, "2024")
        
        width1, height1 = img1.size
        width2, height2 = img2.size
        
        new_image = Image.new('RGB', (width1, height1 + height2), (255, 255, 255))
        new_image.paste(img1, (0, 0))
        new_image.paste(img2, (0, height1))
        
        output_path = filedialog.asksaveasfilename(defaultextension=".jpg", filetypes=[("JPEG files", "*.jpg"), ("PNG files", "*.png")])
        if output_path:
            new_image.save(output_path)
            messagebox.showinfo("图片合成", f"图片已成功合并并保存到 {output_path}")
            
            new_image.thumbnail((300, 300))
            tk_image = ImageTk.PhotoImage(new_image)
            self.image_panel.config(image=tk_image)
            self.image_panel.image = tk_image
        
        self.first_image_path = None
        self.second_image_path = None
        self.image_panel.config(image='')
        messagebox.showinfo("复位", "程序已复位，可重新上传图片。")

    def resize_image(self, img, max_size=(2000, 2000), max_ratio=0.8):
        # 检查图像大小是否超过最大尺寸
        width, height = img.size
        max_width, max_height = max_size
        # 缩放比例，确保图像不超出最大宽度和高度
        ratio = min(max_width / width, max_height / height, max_ratio)
        
        if ratio < 1:
            new_width = int(width * ratio)
            new_height = int(height * ratio)
            img = img.resize((new_width, new_height), Image.LANCZOS)
        return img

    def resize_images_to_same_width(self, img1, img2):
        # 获取两张图的宽度
        width1, height1 = img1.size
        width2, height2 = img2.size
        
        # 选择较小的宽度
        new_width = min(width1, width2)
        
        # 计算按比例缩放后的高度
        new_height1 = int(height1 * (new_width / width1))
        new_height2 = int(height2 * (new_width / width2))
        
        # 调整大小
        img1 = img1.resize((new_width, new_height1), Image.LANCZOS)
        img2 = img2.resize((new_width, new_height2), Image.LANCZOS)
        
        return img1, img2

    def add_text_to_image(self, image, text):
        draw = ImageDraw.Draw(image)
        
        # 获取图片宽度并计算字体大小
        image_width = image.size[0]
        font_size = int(image_width * 0.10)  # 字体大小为图片宽度的 10%
        
        # 设置自定义字体路径
        font_path = r"C:\Users\Lumix\AppData\Local\Microsoft\Windows\Fonts\LCD-BOLD-5.ttf"
        
        try:
            font = ImageFont.truetype(font_path, font_size)
        except IOError:
            font = ImageFont.load_default()
        
        # 设置文字位置、颜色等
        text_position = (10, 10)
        text_color = (255, 165, 0)  # 橙黄色
        stroke_color = (139, 0, 0)  # 深红色描边
        
        # 绘制描边（文字偏移）
        for offset in [-2, 0, 2]:
            draw.text((text_position[0] + offset, text_position[1] + offset), text, fill=stroke_color, font=font)
        
        # 绘制橙黄色文字
        draw.text(text_position, text, fill=text_color, font=font)

# 创建并运行应用
root = tk.Tk()
app = ImageCombinerApp(root)
root.mainloop()

获取西游记的对应图片，可以对小红书已经合成的图片进行裁切，由于我这边看到的很多图都是一比一组合的，因此可以很方便将图片分开：

import sys
import random
import string
from PIL import Image

def generate_random_filename():
    return ''.join(random.choices(string.digits, k=8)) + '.jpg'

def split_image(image_path):
    # 打开图像
    image = Image.open(image_path)
    width, height = image.size
    half_height = height // 2

    # 分割图像
    upper_half = image.crop((0, 0, width, half_height))
    lower_half = image.crop((0, half_height, width, height))

    # 生成随机文件名
    upper_filename = generate_random_filename()
    lower_filename = generate_random_filename()

    # 保存分割后的图像
    upper_half.save(upper_filename)
    lower_half.save(lower_filename)

    print(f"图像已成功分割并保存为 {upper_filename} 和 {lower_filename}")

if __name__ == "__main__":
    # 检查是否提供了图像路径
    if len(sys.argv) < 2:
        print("请将图像文件拖动到此脚本上运行。")
    else:
        # 获取图像路径
        image_path = sys.argv[1]
        split_image(image_path)