添加 dockerfile.example

优化了提取的关键帧中含白屏或黑屏的问题

3.0/毕设.py

@@ -0,0 +1,576 @@
+import cv2
+import numpy as np
+from skimage.metrics import structural_similarity as ssim
+from moviepy.editor import VideoFileClip
+from PIL import Image
+import os
+from scipy.signal import find_peaks
+import torch
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+import whisper
+from collections import defaultdict
+import re
+from reportlab.lib.pagesizes import A4
+from reportlab.pdfgen import canvas
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.platypus import Paragraph, Image as RLImage
+from reportlab.lib.units import inch
+import threading
+import pdfkit
+from jinja2 import Environment
+import io
+import base64
+
+# 全局配置
+SSIM_THRESHOLD = 0.85  # 关键帧去重阈值
+FRAME_INTERVAL = 2  # 抽帧间隔（秒）
+TRANSITION_WORDS = ["接下来", "下一页", "如图"]  # 过渡词过滤列表
+WKHTMLTOPDF_PATH = r"D:\wkhtmltopdf\bin\wkhtmltopdf.exe"
+
+
+class PPTSummarizer:
+    def __init__(self, video_path, output_dir=None):
+        self.video_path = video_path
+        # 如果没有指定输出目录，则使用默认目录
+        if output_dir is None:
+            # 使用视频文件名作为输出目录名
+            video_name = os.path.splitext(os.path.basename(video_path))[0]
+            self.output_dir = os.path.join("output", video_name)
+        else:
+            self.output_dir = output_dir
+
+        self.frames = []
+        self.key_frames = []
+        self.text_content = []
+        self.frame_timestamps = []
+        self.aligned_data = []
+        self.processing_complete = threading.Event()
+
+        # 创建输出目录
+        if not os.path.exists(self.output_dir):
+            os.makedirs(self.output_dir)
+
+        # 初始化whisper模型
+        self.whisper_model = whisper.load_model("tiny", device="cpu")
+
+    def extract_frames(self):
+        """提取视频帧"""
+        try:
+            # 使用VideoFileClip替代cv2
+            video = VideoFileClip(self.video_path)
+            duration = video.duration
+            fps = video.fps
+
+            # 计算采样间隔
+            sample_interval = max(1 / fps, FRAME_INTERVAL)
+            timestamps = np.arange(0, duration, sample_interval)
+
+            print(f"开始提取帧，视频时长：{duration:.2f}秒，FPS：{fps}")
+
+            # 提取帧
+            for t in timestamps:
+                try:
+                    frame = video.get_frame(t)
+                    # 转换为BGR格式（OpenCV格式）
+                    frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+                    self.frames.append(frame_bgr)
+                    self.frame_timestamps.append(t)
+                except Exception as e:
+                    print(f"提取帧 {t}s 时出错: {str(e)}")
+                    continue
+
+            video.close()
+            print(f"成功提取 {len(self.frames)} 帧")
+            return fps
+
+        except Exception as e:
+            print(f"视频处理出错: {str(e)}")
+            return 0
+
+    def process_audio(self):
+        """处理音频"""
+        try:
+            print("开始语音识别...")
+            # 使用更大的模型以提高识别准确度
+            result = self.whisper_model.transcribe(
+                self.video_path,
+                fp16=False,
+                language="zh",
+                task="transcribe",
+                verbose=True
+            )
+            segments = result.get("segments", [])
+            print(f"语音识别完成，共识别出 {len(segments)} 个片段")
+
+            # 打印识别结果
+            for i, seg in enumerate(segments):
+                try:
+                    print(f"片段 {i + 1}: {seg['start']:.1f}s - {seg['end']:.1f}s: {seg['text']}")
+                except UnicodeEncodeError:
+                    print(f"片段 {i + 1}: {seg['start']:.1f}s - {seg['end']:.1f}s: [文本包含特殊字符]")
+
+            # 生成页面时间段
+            intervals = []
+            for i in range(len(self.frame_timestamps)):
+                start = self.frame_timestamps[i]
+                end = self.frame_timestamps[i + 1] if i < len(self.frame_timestamps) - 1 else self.frame_timestamps[
+                                                                                                  -1] + 1
+                intervals.append((start, end))
+                print(f"页面 {i + 1} 时间段: {start:.1f}s - {end:.1f}s")
+
+            # 改进的对齐逻辑
+            page_texts = defaultdict(list)
+            page_segments = defaultdict(list)  # 存储每个页面对应的片段
+            all_texts = []  # 存储所有文本片段
+            used_texts = set()  # 跟踪已使用的文本
+
+            # 第一步：收集所有文本片段
+            for seg in segments:
+                try:
+                    seg_start = seg["start"]
+                    seg_end = seg["end"]
+                    seg_text = seg["text"].strip()
+                    all_texts.append((seg_start, seg_end, seg_text))
+                except Exception as e:
+                    print(f"处理片段时出错: {str(e)}")
+                    continue
+
+            # 第二步：将文本分配到各个页面
+            for start, end, text in all_texts:
+                try:
+                    # 找到与当前片段时间重叠的所有页面
+                    overlapping_pages = []
+                    for page_idx, (page_start, page_end) in enumerate(intervals):
+                        if (start <= page_end and end >= page_start):
+                            overlapping_pages.append((page_idx, page_start, page_end))
+
+                    # 如果找到重叠页面，将文本添加到最合适的页面
+                    if overlapping_pages:
+                        # 计算每个页面的重叠时间
+                        page_overlaps = []
+                        for page_idx, page_start, page_end in overlapping_pages:
+                            overlap_start = max(start, page_start)
+                            overlap_end = min(end, page_end)
+                            overlap_duration = overlap_end - overlap_start
+                            page_overlaps.append((page_idx, overlap_duration))
+
+                        # 按重叠时间排序
+                        page_overlaps.sort(key=lambda x: x[1], reverse=True)
+
+                        # 将文本添加到重叠时间最长的页面
+                        best_page = page_overlaps[0][0]
+                        if text not in used_texts:  # 确保文本未被使用
+                            page_texts[best_page].append(text)
+                            page_segments[best_page].append((start, end, text))
+                            used_texts.add(text)
+                            print(f"将文本 '{text}' 添加到页面 {best_page + 1}")
+                except Exception as e:
+                    print(f"分配文本时出错: {str(e)}")
+                    continue
+
+            # 第三步：优化每个页面的文本
+            self.aligned_data = []
+            for idx in range(len(intervals)):
+                try:
+                    # 获取当前页面的所有片段
+                    segments = page_segments[idx]
+
+                    # 按时间排序
+                    segments.sort(key=lambda x: x[0])
+
+                    # 合并相邻的相似文本
+                    merged_texts = []
+                    current_text = ""
+                    last_end_time = 0
+
+                    for start, end, text in segments:
+                        # 如果当前文本为空，直接添加
+                        if not current_text:
+                            current_text = text
+                            last_end_time = end
+                            continue
+
+                        # 计算时间间隔
+                        time_gap = start - last_end_time
+
+                        # 如果时间间隔小于3秒，合并文本
+                        if time_gap < 3.0:  # 增加时间间隔阈值
+                            current_text += " " + text
+                        else:
+                            merged_texts.append(current_text)
+                            current_text = text
+
+                        last_end_time = end
+
+                    # 添加最后一个文本
+                    if current_text:
+                        merged_texts.append(current_text)
+
+                    # 合并所有文本
+                    final_text = " ".join(merged_texts)
+
+                    # 如果当前页面文本为空，尝试从前一页面获取
+                    if not final_text and idx > 0:
+                        final_text = self.aligned_data[idx - 1]["text"]
+
+                    # 优化文本
+                    optimized_text = self.optimize_text(final_text)
+
+                    if optimized_text:
+                        print(f"页面 {idx + 1} 的优化后文本内容: {optimized_text}")
+
+                    self.aligned_data.append({
+                        "page": idx,
+                        "start_time": intervals[idx][0],
+                        "end_time": intervals[idx][1],
+                        "text": optimized_text
+                    })
+                except Exception as e:
+                    print(f"处理页面 {idx + 1} 时出错: {str(e)}")
+                    # 添加空数据
+                    self.aligned_data.append({
+                        "page": idx,
+                        "start_time": intervals[idx][0],
+                        "end_time": intervals[idx][1],
+                        "text": ""
+                    })
+
+            # 第四步：确保所有文本都被包含
+            # 检查是否有遗漏的文本片段
+            for start, end, text in all_texts:
+                try:
+                    if text not in used_texts:
+                        # 找到最后一个非空页面
+                        last_non_empty_page = -1
+                        for i in range(len(self.aligned_data) - 1, -1, -1):
+                            if self.aligned_data[i]["text"]:
+                                last_non_empty_page = i
+                                break
+
+                        if last_non_empty_page >= 0:
+                            self.aligned_data[last_non_empty_page]["text"] += " " + text
+                            print(f"将遗漏的文本 '{text}' 添加到页面 {last_non_empty_page + 1}")
+                except Exception as e:
+                    print(f"处理遗漏文本时出错: {str(e)}")
+                    continue
+
+            # 保存对齐数据到文件
+            try:
+                with open(os.path.join(self.output_dir, 'aligned_data.txt'), 'w', encoding='utf-8') as f:
+                    for data in self.aligned_data:
+                        f.write(f"页面 {data['page'] + 1}:\n")
+                        f.write(f"时间: {data['start_time']:.1f}s - {data['end_time']:.1f}s\n")
+                        f.write(f"文本: {data['text']}\n\n")
+                print("对齐数据已保存到文件")
+            except Exception as e:
+                print(f"保存对齐数据时出错: {str(e)}")
+
+        except Exception as e:
+            print(f"音频处理出错: {str(e)}")
+            self.aligned_data = []
+
+    def process_frames(self):
+        """处理视频帧"""
+        try:
+            print("开始处理视频帧...")
+            # 计算帧间相似度
+            similarities = []
+            for i in range(len(self.frames) - 1):
+                try:
+                    frame1 = cv2.cvtColor(self.frames[i], cv2.COLOR_BGR2GRAY)
+                    frame2 = cv2.cvtColor(self.frames[i + 1], cv2.COLOR_BGR2GRAY)
+                    similarity = ssim(frame1, frame2)
+                    similarities.append(similarity)
+                except Exception as e:
+                    print(f"计算帧 {i} 相似度时出错: {str(e)}")
+                    similarities.append(1.0)  # 出错时假设帧相似
+
+            # 使用自适应阈值
+            mean_similarity = np.mean(similarities)
+            std_similarity = np.std(similarities)
+            adaptive_threshold = mean_similarity - 2 * std_similarity
+
+            # 使用峰值检测找到关键帧
+            peaks, _ = find_peaks([1 - s for s in similarities],
+                                  height=1 - adaptive_threshold,
+                                  distance=int(len(similarities) / 20))  # 最小距离
+
+            # 保存关键帧
+            for peak in peaks:
+                if not self.is_blank_frame(self.frames[peak]):
+                    self.key_frames.append(self.frames[peak])
+
+            print(f"找到 {len(self.key_frames)} 个关键帧")
+
+        except Exception as e:
+            print(f"处理视频帧时出错: {str(e)}")
+
+    def is_blank_frame(self, frame, threshold=30):
+        """检测是否为空白帧"""
+        try:
+            # 转换为灰度图
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+            # 计算图像统计特征
+            mean = np.mean(gray)
+            std_dev = np.std(gray)
+
+            # 检查是否为纯黑或纯白
+            is_black = mean < 10 and std_dev < 5
+            is_white = mean > 245 and std_dev < 5
+
+            # 检查是否有足够的细节
+            has_detail = std_dev > threshold
+
+            return is_black or is_white or not has_detail
+        except Exception as e:
+            print(f"检查空白帧时出错: {str(e)}")
+            return True
+
+    def optimize_text(self, text):
+        """文本优化"""
+        try:
+            if not text:
+                return ""
+
+            # 过滤过渡词
+            sentences = re.split(r'[。！？]', text)
+            filtered = []
+            seen = set()
+            for sent in sentences:
+                sent = sent.strip()
+                if (len(sent) >= 10
+                        and not any(word in sent for word in TRANSITION_WORDS)
+                        and sent not in seen):
+                    filtered.append(sent)
+                    seen.add(sent)
+
+            result = '。'.join(filtered) + '。' if filtered else ""
+            if result:
+                print(f"优化后的文本: {result}")
+            return result
+        except Exception as e:
+            print(f"文本优化时出错: {str(e)}")
+            return text
+
+    def save_results(self):
+        """保存结果"""
+        try:
+            # 检查输出目录权限
+            if not os.access(self.output_dir, os.W_OK):
+                print(f"错误：没有写入权限: {self.output_dir}")
+                return
+
+            # 生成PDF文档
+            pdf_path = os.path.join(self.output_dir, 'summary.pdf')
+
+            # 创建临时HTML文件
+            temp_html = os.path.join(self.output_dir, "_temp_pdf.html")
+            temp_img_dir = os.path.join(self.output_dir, "_temp_pdf_images")
+            os.makedirs(temp_img_dir, exist_ok=True)
+
+            try:
+                # 使用绝对路径
+                abs_temp_img_dir = os.path.abspath(temp_img_dir)
+
+                html_content = """
+                <!DOCTYPE html>
+                <html>
+                <head>
+                    <meta charset="UTF-8">
+                    <style>
+                        @page {
+                            margin: 20px;
+                            size: A4;
+                        }
+                        body {
+                            font-family: "Microsoft YaHei", "SimSun", sans-serif;
+                            line-height: 1.6;
+                            margin: 0;
+                            padding: 20px;
+                        }
+                        .page {
+                            page-break-inside: avoid;
+                            margin-bottom: 30px;
+                            padding: 20px;
+                            background-color: white;
+                        }
+                        img {
+                            max-width: 100%;
+                            height: auto;
+                            display: block;
+                            margin: 10px auto;
+                        }
+                        .timestamp {
+                            color: #666;
+                            font-size: 12pt;
+                            margin: 10px 0;
+                        }
+                        .content {
+                            font-size: 14pt;
+                            line-height: 1.6;
+                            margin: 15px 0;
+                        }
+                        h1 {
+                            text-align: center;
+                            color: #333;
+                            margin-bottom: 30px;
+                        }
+                        h2 {
+                            color: #444;
+                            margin: 15px 0;
+                        }
+                    </style>
+                </head>
+                <body>
+                    <h1>PPT视频结构化摘要</h1>
+                    {% for page in pages %}
+                    <div class="page">
+                        <h2>页面 {{ page.num }}</h2>
+                        <div class="timestamp">{{ page.time }}</div>
+                        <img src="{{ page.image_path }}" alt="页面截图">
+                        <div class="content">{{ page.text }}</div>
+                    </div>
+                    {% endfor %}
+                </body>
+                </html>
+                """
+
+                pages_data = []
+                for idx, frame in enumerate(self.key_frames):
+                    try:
+                        img_filename = f"page_{idx}.jpg"
+                        img_path = os.path.join(abs_temp_img_dir, img_filename)
+
+                        # 将numpy数组转换为PIL Image对象
+                        if len(frame.shape) == 3 and frame.shape[2] == 3:
+                            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                        else:
+                            frame_rgb = frame
+
+                        # 创建PIL Image对象
+                        img = Image.fromarray(frame_rgb)
+
+                        # 调整图片大小
+                        max_width = 800
+                        if img.width > max_width:
+                            ratio = max_width / img.width
+                            new_height = int(img.height * ratio)
+                            img = img.resize((max_width, new_height), Image.Resampling.LANCZOS)
+
+                        # 保存图片
+                        img.save(img_path, format='JPEG', quality=85, optimize=True)
+
+                        # 获取从开始到当前帧的所有文本
+                        current_time = self.aligned_data[idx]['end_time']
+
+                        # 收集从开始到当前时间点的所有文本
+                        texts = []
+                        for data in self.aligned_data:
+                            if data['end_time'] <= current_time:
+                                if data['text']:
+                                    texts.append(data['text'])
+
+                        # 合并文本
+                        combined_text = " ".join(texts)
+
+                        # 如果只有一帧关键帧，显示整个视频的所有文本
+                        if len(self.key_frames) == 1:
+                            all_texts = []
+                            for data in self.aligned_data:
+                                if data['text']:
+                                    all_texts.append(data['text'])
+                            combined_text = " ".join(all_texts)
+
+                        # 添加file://前缀到图片路径
+                        img_path_with_prefix = f"file:///{img_path.replace(os.sep, '/')}"
+
+                        pages_data.append({
+                            "num": idx + 1,
+                            "time": f"{self.aligned_data[idx]['start_time']:.1f}s - {self.aligned_data[idx]['end_time']:.1f}s",
+                            "image_path": img_path_with_prefix,
+                            "text": combined_text
+                        })
+                    except Exception as e:
+                        print(f"处理页面 {idx + 1} 时出错: {str(e)}")
+                        continue
+
+                # 生成HTML文件
+                env = Environment()
+                template = env.from_string(html_content)
+                with open(temp_html, "w", encoding="utf-8") as f:
+                    f.write(template.render(pages=pages_data))
+
+                # 设置PDF生成选项
+                options = {
+                    "enable-local-file-access": "",
+                    "encoding": "UTF-8",
+                    "margin-top": "15mm",
+                    "margin-bottom": "15mm",
+                    "margin-left": "15mm",
+                    "margin-right": "15mm",
+                    "quiet": "",
+                    "print-media-type": "",
+                    "page-size": "A4",
+                    "orientation": "Portrait"
+                }
+                config = pdfkit.configuration(wkhtmltopdf=WKHTMLTOPDF_PATH)
+
+                # 生成PDF
+                pdfkit.from_file(
+                    temp_html,
+                    pdf_path,
+                    configuration=config,
+                    options=options
+                )
+                print(f"PDF已保存到: {pdf_path}")
+
+            finally:
+                # 清理临时文件
+                if os.path.exists(temp_html):
+                    os.remove(temp_html)
+                if os.path.exists(temp_img_dir):
+                    for f in os.listdir(temp_img_dir):
+                        os.remove(os.path.join(temp_img_dir, f))
+                    os.rmdir(temp_img_dir)
+
+        except Exception as e:
+            print(f"保存结果时出错: {str(e)}")
+
+    def process(self):
+        """处理视频并生成摘要"""
+        try:
+            start_time = time.time()
+            print("开始处理视频...")
+
+            # 提取视频帧
+            self.extract_frames()
+
+            # 创建线程池
+            with ThreadPoolExecutor(max_workers=2) as executor:
+                # 提交音频处理和帧处理任务
+                audio_future = executor.submit(self.process_audio)
+                frames_future = executor.submit(self.process_frames)
+
+                # 等待两个任务完成
+                audio_future.result()
+                frames_future.result()
+
+            print("生成摘要...")
+            self.save_results()
+
+            end_time = time.time()
+            print(f"处理完成！总耗时：{end_time - start_time:.2f}秒")
+
+        except Exception as e:
+            print(f"处理过程出错: {str(e)}")
+            raise  # 重新抛出异常以便调试
+
+
+if __name__ == "__main__":
+    # 使用示例
+    video_path = "D:/python项目文件/1/input3.mp4"  # 替换为实际的视频路径
+    output_dir = "custom_output"  # 自定义输出路径
+    summarizer = PPTSummarizer(video_path, output_dir)
+    summarizer.process()

4，0/毕设.py

@@ -0,0 +1,525 @@
+import os
+import re
+import base64
+import warnings
+import imageio
+import whisper
+import numpy as np
+import pdfkit
+from PIL import Image
+from skimage.metrics import structural_similarity as ssim
+from collections import defaultdict
+import subprocess
+from jinja2 import Environment
+import cv2
+from scipy.signal import find_peaks
+from skimage.feature import hog
+from skimage.color import rgb2gray
+
+# ======================== 全局配置 ========================
+warnings.filterwarnings("ignore", message="FP16 is not supported on CPU; using FP32 instead")
+VIDEO_PATH = "D:/python项目文件/1/input.mp4"  # 输入视频路径
+MODEL_DIR = "D:/whisper_models"  # Whisper模型目录
+FFMPEG_BIN = r"D:\Program Files\ffmpeg\bin"  # FFmpeg安装路径
+WKHTMLTOPDF_PATH = r"D:\wkhtmltopdf\bin\wkhtmltopdf.exe"  # wkhtmltopdf路径
+SSIM_THRESHOLD = 0.85  # 关键帧去重阈值
+FRAME_INTERVAL = 2  # 抽帧间隔（秒）
+OUTPUT_DIR = "D:\桌面文件\python\output"  # 输出目录
+TRANSITION_WORDS = ["接下来", "下一页", "如图"]  # 过渡词过滤列
+HOG_THRESHOLD = 0.7  # HOG特征相似度阈值
+COLOR_THRESHOLD = 0.8  # 颜色直方图相似度阈值
+WHISPER_MODEL = "base"  # Whisper模型大小
+PROFESSIONAL_TERMS = {
+    "人工智能": "AI",
+    "机器学习": "ML",
+    "深度学习": "DL",
+    "神经网络": "NN",
+    "卷积神经网络": "CNN",
+    "循环神经网络": "RNN",
+    "自然语言处理": "NLP",
+    "计算机视觉": "CV",
+    "大数据": "Big Data",
+    "云计算": "Cloud Computing"
+}  # 专业术语词典
+
+
+# ========================================================
+
+# ---------------------- 核心功能模块 ----------------------
+class VideoProcessor:
+    def __init__(self):
+        os.environ["PATH"] = FFMPEG_BIN + os.pathsep + os.environ["PATH"]
+
+    @staticmethod
+    def check_ffmpeg():
+        """验证FFmpeg可用性"""
+        try:
+            subprocess.run(["ffmpeg", "-version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            print("[系统] FFmpeg验证成功")
+            return True
+        except Exception as e:
+            print(f"[错误] FFmpeg验证失败: {str(e)}")
+            return False
+
+    @staticmethod
+    def calculate_color_histogram(frame):
+        """计算颜色直方图特征"""
+        hist = cv2.calcHist([frame], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
+        cv2.normalize(hist, hist)
+        return hist.flatten()
+
+    @staticmethod
+    def calculate_hog_features(frame):
+        """计算HOG特征"""
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        features = hog(gray, orientations=8, pixels_per_cell=(16, 16),
+                       cells_per_block=(1, 1), visualize=False)
+        return features
+
+    @staticmethod
+    def is_ppt_transition(frame1, frame2):
+        """检测PPT页面切换"""
+        # 转换为灰度图
+        gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+        gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+
+        # 计算边缘
+        edges1 = cv2.Canny(gray1, 100, 200)
+        edges2 = cv2.Canny(gray2, 100, 200)
+
+        # 计算边缘差异
+        diff = cv2.absdiff(edges1, edges2)
+        return np.mean(diff) > 50  # 阈值可调整
+
+    @staticmethod
+    def extract_keyframes(video_path: str) -> tuple:
+        """提取去重关键帧及其时间戳（多特征融合）"""
+        try:
+            reader = imageio.get_reader(video_path)
+            fps = reader.get_meta_data()["fps"]
+            keyframes = []
+            timestamps = []
+            prev_frame = None
+            prev_features = None
+
+            for idx, frame in enumerate(reader):
+                curr_time = idx / fps
+                if curr_time - (timestamps[-1] if timestamps else 0) < FRAME_INTERVAL:
+                    continue
+
+                # 多特征相似度计算
+                if prev_frame is not None:
+                    # 1. SSIM相似度
+                    gray_prev = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
+                    gray_curr = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                    ssim_score = ssim(gray_prev, gray_curr)
+
+                    # 2. 颜色直方图相似度
+                    hist_prev = VideoProcessor.calculate_color_histogram(prev_frame)
+                    hist_curr = VideoProcessor.calculate_color_histogram(frame)
+                    color_sim = cv2.compareHist(hist_prev, hist_curr, cv2.HISTCMP_CORREL)
+
+                    # 3. HOG特征相似度
+                    hog_prev = VideoProcessor.calculate_hog_features(prev_frame)
+                    hog_curr = VideoProcessor.calculate_hog_features(frame)
+                    hog_sim = np.dot(hog_prev, hog_curr) / (np.linalg.norm(hog_prev) * np.linalg.norm(hog_curr))
+
+                    # 4. PPT页面切换检测
+                    is_transition = VideoProcessor.is_ppt_transition(prev_frame, frame)
+
+                    # 综合判断
+                    if (ssim_score > SSIM_THRESHOLD and
+                            color_sim > COLOR_THRESHOLD and
+                            hog_sim > HOG_THRESHOLD and
+                            not is_transition):
+                        continue
+
+                keyframes.append(Image.fromarray(frame))
+                timestamps.append(curr_time)
+                prev_frame = frame
+
+            reader.close()
+            print(f"[图像] 关键帧提取完成，共{len(keyframes)}帧")
+            return keyframes, timestamps
+        except Exception as e:
+            print(f"[错误] 关键帧提取失败: {str(e)}")
+            return [], []
+
+    @staticmethod
+    def transcribe_audio(video_path: str, model_name: str = WHISPER_MODEL) -> list:
+        """语音识别与时间戳获取（支持中英文混合）"""
+        try:
+            # 使用更大的模型提高准确率
+            model = whisper.load_model(model_name, device="cpu", download_root=MODEL_DIR)
+
+            # 配置转写参数
+            result = model.transcribe(
+                video_path,
+                fp16=False,
+                language="zh",
+                task="transcribe",
+                verbose=True,
+                initial_prompt="这是一段包含中英文的PPT讲解视频，可能包含专业术语。"
+            )
+
+            segments = result.get("segments", [])
+
+            # 后处理：专业术语替换
+            for seg in segments:
+                text = seg["text"]
+                for cn, en in PROFESSIONAL_TERMS.items():
+                    text = text.replace(cn, f"{cn}({en})")
+                seg["text"] = text
+
+            return segments
+        except Exception as e:
+            print(f"[错误] 语音识别失败: {str(e)}")
+            return []
+
+
+# ---------------------- 业务逻辑模块 ----------------------
+class ContentAligner:
+    @staticmethod
+    def generate_page_intervals(timestamps: list, duration: float) -> list:
+        """生成页面时间段"""
+        intervals = []
+        for i in range(len(timestamps)):
+            start = timestamps[i]
+            end = timestamps[i + 1] if i < len(timestamps) - 1 else duration
+            intervals.append((start, end))
+        return intervals
+
+    @staticmethod
+    def calculate_text_similarity(text1: str, text2: str) -> float:
+        """计算文本相似度"""
+        # 使用简单的词重叠度计算
+        words1 = set(re.findall(r'\w+', text1.lower()))
+        words2 = set(re.findall(r'\w+', text2.lower()))
+        if not words1 or not words2:
+            return 0.0
+        intersection = words1.intersection(words2)
+        union = words1.union(words2)
+        return len(intersection) / len(union)
+
+    @staticmethod
+    def find_best_match(segments: list, intervals: list) -> dict:
+        """为每个语音片段找到最佳匹配的页面"""
+        page_texts = defaultdict(list)
+        unmatched_segments = []
+
+        for seg in segments:
+            seg_start = seg["start"]
+            best_match = None
+            best_score = 0.0
+
+            # 1. 首先尝试时间戳匹配
+            for page_idx, (start, end) in enumerate(intervals):
+                if start <= seg_start < end:
+                    best_match = page_idx
+                    break
+
+            # 2. 如果时间戳匹配失败，尝试文本相似度匹配
+            if best_match is None:
+                for page_idx, (start, end) in enumerate(intervals):
+                    # 获取该页面的所有文本
+                    page_text = " ".join([s["text"] for s in segments if start <= s["start"] < end])
+                    similarity = ContentAligner.calculate_text_similarity(seg["text"], page_text)
+                    if similarity > best_score:
+                        best_score = similarity
+                        best_match = page_idx
+
+            # 3. 如果找到匹配，添加到对应页面
+            if best_match is not None:
+                page_texts[best_match].append(seg)
+            else:
+                unmatched_segments.append(seg)
+
+        # 4. 处理未匹配的片段
+        if unmatched_segments:
+            print(f"[警告] 发现{len(unmatched_segments)}个未匹配的语音片段")
+            # 将未匹配片段添加到最近的页面
+            for seg in unmatched_segments:
+                closest_page = min(range(len(intervals)),
+                                   key=lambda i: abs(seg["start"] - (intervals[i][0] + intervals[i][1]) / 2))
+                page_texts[closest_page].append(seg)
+
+        return page_texts
+
+    @staticmethod
+    def align_content(video_path: str, timestamps: list) -> list:
+        """语音-画面对齐主逻辑（改进版）"""
+        try:
+            reader = imageio.get_reader(video_path)
+            duration = reader.get_meta_data()["duration"]
+            reader.close()
+        except:
+            duration = timestamps[-1] + FRAME_INTERVAL
+
+        segments = VideoProcessor.transcribe_audio(video_path)
+        intervals = ContentAligner.generate_page_intervals(timestamps, duration)
+
+        # 使用改进的匹配算法
+        page_texts = ContentAligner.find_best_match(segments, intervals)
+
+        # 生成最终的对齐数据
+        aligned_data = []
+        for idx in range(len(intervals)):
+            text = " ".join([seg["text"] for seg in page_texts.get(idx, [])])
+            aligned_data.append({
+                "page": idx,
+                "start_time": intervals[idx][0],
+                "end_time": intervals[idx][1],
+                "text": text
+            })
+
+        return aligned_data
+
+
+# ---------------------- 摘要生成模块 ----------------------
+class SummaryGenerator:
+    @staticmethod
+    def optimize_text(text: str) -> str:
+        """文本浓缩优化"""
+        sentences = re.split(r'[。！？]', text)
+        filtered = []
+        seen = set()
+        for sent in sentences:
+            sent = sent.strip()
+            if (len(sent) >= 10
+                    and not any(word in sent for word in TRANSITION_WORDS)
+                    and sent not in seen):
+                filtered.append(sent)
+                seen.add(sent)
+        return '。'.join(filtered) + '。' if filtered else ""
+
+    @staticmethod
+    def generate_html(aligned_data: list, keyframes: list, output_dir: str):
+        """生成HTML报告"""
+        pages_data = []
+        temp_img_dir = os.path.join(output_dir, "_temp_images")
+        os.makedirs(temp_img_dir, exist_ok=True)
+
+        try:
+            for idx, frame in enumerate(keyframes):
+                img_path = os.path.join(temp_img_dir, f"page_{idx}.jpg")
+                frame.save(img_path)
+                with open(img_path, "rb") as f:
+                    img_data = base64.b64encode(f.read()).decode("utf-8")
+
+                pages_data.append({
+                    "num": idx + 1,
+                    "time": f"{aligned_data[idx]['start_time']:.1f}s - {aligned_data[idx]['end_time']:.1f}s",
+                    "image": f"data:image/jpeg;base64,{img_data}",
+                    "text": SummaryGenerator.optimize_text(aligned_data[idx]["text"])
+                })
+
+            env = Environment()
+            template = env.from_string("""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <title>PPT视频摘要报告</title>
+                <style>
+                    .page { margin: 20px; padding: 15px; border: 1px solid #eee; }
+                    img { max-width: 800px; height: auto; }
+                    .timestamp { color: #666; font-size: 0.9em; }
+                    .content { margin-top: 10px; }
+                </style>
+            </head>
+            <body>
+                <h1>PPT视频结构化摘要</h1>
+                {% for page in pages %}
+                <div class="page">
+                    <h2>页面 {{ page.num }}</h2>
+                    <div class="timestamp">{{ page.time }}</div>
+                    <img src="{{ page.image }}" alt="页面截图">
+                    <div class="content">{{ page.text }}</div>
+                </div>
+                {% endfor %}
+            </body>
+            </html>
+            """)
+
+            output_path = os.path.join(output_dir, "summary.html")
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(template.render(pages=pages_data))
+            print(f"[输出] HTML报告已生成: {output_path}")
+        finally:
+            for f in os.listdir(temp_img_dir):
+                os.remove(os.path.join(temp_img_dir, f))
+            os.rmdir(temp_img_dir)
+
+    @staticmethod
+    def generate_pdf(aligned_data: list, keyframes: list, output_dir: str):
+        """生成PDF报告（优化版）"""
+        temp_html = os.path.join(output_dir, "_temp_pdf.html")
+        temp_img_dir = os.path.join(output_dir, "_temp_pdf_images")
+        os.makedirs(temp_img_dir, exist_ok=True)
+
+        try:
+            # 使用绝对路径
+            abs_temp_img_dir = os.path.abspath(temp_img_dir)
+
+            html_content = """
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <style>
+                    @page { 
+                        margin: 20mm;
+                        size: A4;
+                    }
+                    body {
+                        font-family: "Microsoft YaHei", "SimSun", sans-serif;
+                        line-height: 1.6;
+                        color: #333;
+                    }
+                    .page {
+                        page-break-inside: avoid;
+                        margin-bottom: 30px;
+                        padding: 20px;
+                        border: 1px solid #eee;
+                        border-radius: 5px;
+                    }
+                    .page-number {
+                        text-align: center;
+                        font-size: 24pt;
+                        font-weight: bold;
+                        margin-bottom: 20px;
+                        color: #2c3e50;
+                    }
+                    .timestamp {
+                        color: #666;
+                        font-size: 12pt;
+                        margin-bottom: 15px;
+                    }
+                    .image-container {
+                        text-align: center;
+                        margin: 20px 0;
+                    }
+                    img {
+                        max-width: 90% !important;
+                        height: auto;
+                        display: block;
+                        margin: 0 auto;
+                        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+                    }
+                    .content {
+                        font-size: 14pt;
+                        line-height: 1.8;
+                        margin-top: 20px;
+                        padding: 15px;
+                        background: #f9f9f9;
+                        border-radius: 5px;
+                    }
+                    .professional-term {
+                        color: #2980b9;
+                        font-weight: bold;
+                    }
+                </style>
+            </head>
+            <body>
+                <h1 style="text-align: center; color: #2c3e50; margin-bottom: 40px;">PPT视频结构化摘要</h1>
+                {% for page in pages %}
+                <div class="page">
+                    <div class="page-number">第 {{ page.num }} 页</div>
+                    <div class="timestamp">时间区间：{{ page.time }}</div>
+                    <div class="image-container">
+                        <img src="{{ page.image_path }}" alt="页面截图">
+                    </div>
+                    <div class="content">{{ page.text }}</div>
+                </div>
+                {% endfor %}
+            </body>
+            </html>
+            """
+
+            pages_data = []
+            for idx, frame in enumerate(keyframes):
+                img_filename = f"page_{idx}.jpg"
+                img_path = os.path.join(abs_temp_img_dir, img_filename)
+                frame.save(img_path)
+                pages_data.append({
+                    "num": idx + 1,
+                    "time": f"{aligned_data[idx]['start_time']:.1f}s - {aligned_data[idx]['end_time']:.1f}s",
+                    "image_path": img_path,
+                    "text": SummaryGenerator.optimize_text(aligned_data[idx]["text"])
+                })
+
+            env = Environment()
+            template = env.from_string(html_content)
+            with open(temp_html, "w", encoding="utf-8") as f:
+                f.write(template.render(pages=pages_data))
+
+            # PDF生成选项
+            options = {
+                "enable-local-file-access": "",
+                "encoding": "UTF-8",
+                "margin-top": "20mm",
+                "margin-bottom": "20mm",
+                "margin-left": "20mm",
+                "margin-right": "20mm",
+                "no-stop-slow-scripts": "",
+                "quiet": "",
+                "dpi": "300",
+                "image-quality": "100",
+                "enable-smart-shrinking": "",
+                "print-media-type": ""
+            }
+            config = pdfkit.configuration(wkhtmltopdf=WKHTMLTOPDF_PATH)
+
+            pdf_path = os.path.join(output_dir, "summary.pdf")
+            pdfkit.from_file(
+                temp_html,
+                pdf_path,
+                configuration=config,
+                options=options
+            )
+            print(f"[输出] PDF报告已生成: {pdf_path}")
+
+        finally:
+            # 清理临时文件
+            if os.path.exists(temp_html):
+                os.remove(temp_html)
+            if os.path.exists(temp_img_dir):
+                for f in os.listdir(temp_img_dir):
+                    os.remove(os.path.join(temp_img_dir, f))
+                os.rmdir(temp_img_dir)
+
+    @classmethod
+    def generate_all(cls, aligned_data: list, keyframes: list, output_dir: str):
+        """生成所有格式报告"""
+        cls.generate_html(aligned_data, keyframes, output_dir)
+        cls.generate_pdf(aligned_data, keyframes, output_dir)
+
+
+# ---------------------- 主流程控制 ----------------------
+def main_process():
+    # 环境检查
+    processor = VideoProcessor()
+    if not processor.check_ffmpeg():
+        return
+    if not os.path.exists(VIDEO_PATH):
+        print(f"[错误] 视频文件不存在: {VIDEO_PATH}")
+        return
+
+    # 关键帧提取
+    keyframes, timestamps = processor.extract_keyframes(VIDEO_PATH)
+    if not keyframes:
+        print("[错误] 未提取到关键帧")
+        return
+
+    # 内容对齐
+    aligned_data = ContentAligner.align_content(VIDEO_PATH, timestamps)
+    if not aligned_data:
+        print("[警告] 未识别到有效语音内容")
+
+    # 生成摘要
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    SummaryGenerator.generate_all(aligned_data, keyframes, OUTPUT_DIR)
+
+
+if __name__ == "__main__":
+    main_process()

5.0/毕设.py

@@ -0,0 +1,548 @@
+import os
+import re
+import base64
+import warnings
+import imageio
+import whisper
+import numpy as np
+import pdfkit
+from PIL import Image
+from skimage.metrics import structural_similarity as ssim
+from collections import defaultdict
+import subprocess
+from jinja2 import Environment
+import cv2
+from scipy.signal import find_peaks
+from skimage.feature import hog
+from skimage.color import rgb2gray
+
+# ======================== 全局配置 ========================
+warnings.filterwarnings("ignore", message="FP16 is not supported on CPU; using FP32 instead")
+VIDEO_PATH = "D:/python项目文件/1/input3.mp4"  # 输入视频路径
+MODEL_DIR = "D:/whisper_models"  # Whisper模型目录
+FFMPEG_BIN = r"D:\Program Files\ffmpeg\bin"  # FFmpeg安装路径
+WKHTMLTOPDF_PATH = r"D:\wkhtmltopdf\bin\wkhtmltopdf.exe"  # wkhtmltopdf路径
+SSIM_THRESHOLD = 0.85  # 关键帧去重阈值
+FRAME_INTERVAL = 2  # 抽帧间隔（秒）
+OUTPUT_DIR = "D:\桌面文件\python\output"  # 输出目录
+TRANSITION_WORDS = ["接下来", "下一页", "如图"]  # 过渡词过滤列
+HOG_THRESHOLD = 0.7  # HOG特征相似度阈值
+COLOR_THRESHOLD = 0.8  # 颜色直方图相似度阈值
+WHISPER_MODEL = "base"  # Whisper模型大小
+PROFESSIONAL_TERMS = {
+    "人工智能": "AI",
+    "机器学习": "ML",
+    "深度学习": "DL",
+    "神经网络": "NN",
+    "卷积神经网络": "CNN",
+    "循环神经网络": "RNN",
+    "自然语言处理": "NLP",
+    "计算机视觉": "CV",
+    "大数据": "Big Data",
+    "云计算": "Cloud Computing"
+}  # 专业术语词典
+
+
+# ========================================================
+
+# ---------------------- 核心功能模块 ----------------------
+class VideoProcessor:
+    def __init__(self):
+        os.environ["PATH"] = FFMPEG_BIN + os.pathsep + os.environ["PATH"]
+
+    @staticmethod
+    def check_ffmpeg():
+        """验证FFmpeg可用性"""
+        try:
+            subprocess.run(["ffmpeg", "-version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            print("[系统] FFmpeg验证成功")
+            return True
+        except Exception as e:
+            print(f"[错误] FFmpeg验证失败: {str(e)}")
+            return False
+
+    @staticmethod
+    def calculate_color_histogram(frame):
+        """计算颜色直方图特征"""
+        hist = cv2.calcHist([frame], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
+        cv2.normalize(hist, hist)
+        return hist.flatten()
+
+    @staticmethod
+    def calculate_hog_features(frame):
+        """计算HOG特征"""
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        features = hog(gray, orientations=8, pixels_per_cell=(16, 16),
+                       cells_per_block=(1, 1), visualize=False)
+        return features
+
+    @staticmethod
+    def is_ppt_transition(frame1, frame2):
+        """检测PPT页面切换"""
+        # 转换为灰度图
+        gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+        gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+
+        # 计算边缘
+        edges1 = cv2.Canny(gray1, 100, 200)
+        edges2 = cv2.Canny(gray2, 100, 200)
+
+        # 计算边缘差异
+        diff = cv2.absdiff(edges1, edges2)
+        return np.mean(diff) > 50  # 阈值可调整
+
+    @staticmethod
+    def extract_keyframes(video_path: str) -> tuple:
+        """提取去重关键帧及其时间戳（多特征融合）"""
+        try:
+            reader = imageio.get_reader(video_path)
+            fps = reader.get_meta_data()["fps"]
+            total_frames = reader.count_frames()
+            print(f"[信息] 视频总帧数: {total_frames}")
+
+            keyframes = []
+            timestamps = []
+            prev_frame = None
+            frame_count = 0
+            last_progress = 0
+
+            for idx, frame in enumerate(reader):
+                # 显示进度
+                progress = int((idx / total_frames) * 100)
+                if progress != last_progress and progress % 5 == 0:  # 每5%显示一次进度
+                    print(f"[进度] 处理中: {progress}% ({idx}/{total_frames}帧)")
+                    last_progress = progress
+
+                curr_time = idx / fps
+                if curr_time - (timestamps[-1] if timestamps else 0) < FRAME_INTERVAL:
+                    continue
+
+                # 多特征相似度计算
+                if prev_frame is not None:
+                    try:
+                        # 1. SSIM相似度（使用简化版本）
+                        gray_prev = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
+                        gray_curr = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                        ssim_score = ssim(gray_prev, gray_curr, win_size=3)
+
+                        # 2. 颜色直方图相似度
+                        hist_prev = VideoProcessor.calculate_color_histogram(prev_frame)
+                        hist_curr = VideoProcessor.calculate_color_histogram(frame)
+                        color_sim = cv2.compareHist(hist_prev, hist_curr, cv2.HISTCMP_CORREL)
+
+                        # 3. HOG特征相似度（仅在SSIM和颜色相似度较高时计算）
+                        if ssim_score > 0.8 and color_sim > 0.8:
+                            hog_prev = VideoProcessor.calculate_hog_features(prev_frame)
+                            hog_curr = VideoProcessor.calculate_hog_features(frame)
+                            hog_sim = np.dot(hog_prev, hog_curr) / (np.linalg.norm(hog_prev) * np.linalg.norm(hog_curr))
+                        else:
+                            hog_sim = 0  # 如果SSIM和颜色相似度低，直接跳过HOG计算
+
+                        # 4. PPT页面切换检测
+                        is_transition = VideoProcessor.is_ppt_transition(prev_frame, frame)
+
+                        # 综合判断
+                        if (ssim_score > SSIM_THRESHOLD and
+                                color_sim > COLOR_THRESHOLD and
+                                hog_sim > HOG_THRESHOLD and
+                                not is_transition):
+                            continue
+                    except Exception as e:
+                        print(f"[警告] 特征计算失败: {str(e)}")
+                        continue
+
+                keyframes.append(Image.fromarray(frame))
+                timestamps.append(curr_time)
+                prev_frame = frame
+                frame_count += 1
+
+                # 每处理100帧强制垃圾回收
+                if frame_count % 100 == 0:
+                    import gc
+                    gc.collect()
+
+            reader.close()
+            print(f"[图像] 关键帧提取完成，共{len(keyframes)}帧")
+            return keyframes, timestamps
+        except Exception as e:
+            print(f"[错误] 关键帧提取失败: {str(e)}")
+            return [], []
+
+    @staticmethod
+    def transcribe_audio(video_path: str, model_name: str = WHISPER_MODEL) -> list:
+        """语音识别与时间戳获取（支持中英文混合）"""
+        try:
+            # 使用更大的模型提高准确率
+            model = whisper.load_model(model_name, device="cpu", download_root=MODEL_DIR)
+
+            # 配置转写参数
+            result = model.transcribe(
+                video_path,
+                fp16=False,
+                language="zh",
+                task="transcribe",
+                verbose=True,
+                initial_prompt="这是一段包含中英文的PPT讲解视频，可能包含专业术语。"
+            )
+
+            segments = result.get("segments", [])
+
+            # 后处理：专业术语替换
+            for seg in segments:
+                text = seg["text"]
+                for cn, en in PROFESSIONAL_TERMS.items():
+                    text = text.replace(cn, f"{cn}({en})")
+                seg["text"] = text
+
+            return segments
+        except Exception as e:
+            print(f"[错误] 语音识别失败: {str(e)}")
+            return []
+
+
+# ---------------------- 业务逻辑模块 ----------------------
+class ContentAligner:
+    @staticmethod
+    def generate_page_intervals(timestamps: list, duration: float) -> list:
+        """生成页面时间段"""
+        intervals = []
+        for i in range(len(timestamps)):
+            start = timestamps[i]
+            end = timestamps[i + 1] if i < len(timestamps) - 1 else duration
+            intervals.append((start, end))
+        return intervals
+
+    @staticmethod
+    def calculate_text_similarity(text1: str, text2: str) -> float:
+        """计算文本相似度"""
+        # 使用简单的词重叠度计算
+        words1 = set(re.findall(r'\w+', text1.lower()))
+        words2 = set(re.findall(r'\w+', text2.lower()))
+        if not words1 or not words2:
+            return 0.0
+        intersection = words1.intersection(words2)
+        union = words1.union(words2)
+        return len(intersection) / len(union)
+
+    @staticmethod
+    def find_best_match(segments: list, intervals: list) -> dict:
+        """为每个语音片段找到最佳匹配的页面"""
+        page_texts = defaultdict(list)
+        unmatched_segments = []
+
+        for seg in segments:
+            seg_start = seg["start"]
+            best_match = None
+            best_score = 0.0
+
+            # 1. 首先尝试时间戳匹配
+            for page_idx, (start, end) in enumerate(intervals):
+                if start <= seg_start < end:
+                    best_match = page_idx
+                    break
+
+            # 2. 如果时间戳匹配失败，尝试文本相似度匹配
+            if best_match is None:
+                for page_idx, (start, end) in enumerate(intervals):
+                    # 获取该页面的所有文本
+                    page_text = " ".join([s["text"] for s in segments if start <= s["start"] < end])
+                    similarity = ContentAligner.calculate_text_similarity(seg["text"], page_text)
+                    if similarity > best_score:
+                        best_score = similarity
+                        best_match = page_idx
+
+            # 3. 如果找到匹配，添加到对应页面
+            if best_match is not None:
+                page_texts[best_match].append(seg)
+            else:
+                unmatched_segments.append(seg)
+
+        # 4. 处理未匹配的片段
+        if unmatched_segments:
+            print(f"[警告] 发现{len(unmatched_segments)}个未匹配的语音片段")
+            # 将未匹配片段添加到最近的页面
+            for seg in unmatched_segments:
+                closest_page = min(range(len(intervals)),
+                                   key=lambda i: abs(seg["start"] - (intervals[i][0] + intervals[i][1]) / 2))
+                page_texts[closest_page].append(seg)
+
+        return page_texts
+
+    @staticmethod
+    def align_content(video_path: str, timestamps: list) -> list:
+        """语音-画面对齐主逻辑（改进版）"""
+        try:
+            reader = imageio.get_reader(video_path)
+            duration = reader.get_meta_data()["duration"]
+            reader.close()
+        except:
+            duration = timestamps[-1] + FRAME_INTERVAL
+
+        segments = VideoProcessor.transcribe_audio(video_path)
+        intervals = ContentAligner.generate_page_intervals(timestamps, duration)
+
+        # 使用改进的匹配算法
+        page_texts = ContentAligner.find_best_match(segments, intervals)
+
+        # 生成最终的对齐数据
+        aligned_data = []
+        for idx in range(len(intervals)):
+            text = " ".join([seg["text"] for seg in page_texts.get(idx, [])])
+            aligned_data.append({
+                "page": idx,
+                "start_time": intervals[idx][0],
+                "end_time": intervals[idx][1],
+                "text": text
+            })
+
+        return aligned_data
+
+
+# ---------------------- 摘要生成模块 ----------------------
+class SummaryGenerator:
+    @staticmethod
+    def optimize_text(text: str) -> str:
+        """文本浓缩优化"""
+        sentences = re.split(r'[。！？]', text)
+        filtered = []
+        seen = set()
+        for sent in sentences:
+            sent = sent.strip()
+            if (len(sent) >= 10
+                    and not any(word in sent for word in TRANSITION_WORDS)
+                    and sent not in seen):
+                filtered.append(sent)
+                seen.add(sent)
+        return '。'.join(filtered) + '。' if filtered else ""
+
+    @staticmethod
+    def generate_html(aligned_data: list, keyframes: list, output_dir: str):
+        """生成HTML报告"""
+        pages_data = []
+        temp_img_dir = os.path.join(output_dir, "_temp_images")
+        os.makedirs(temp_img_dir, exist_ok=True)
+
+        try:
+            for idx, frame in enumerate(keyframes):
+                img_path = os.path.join(temp_img_dir, f"page_{idx}.jpg")
+                frame.save(img_path)
+                with open(img_path, "rb") as f:
+                    img_data = base64.b64encode(f.read()).decode("utf-8")
+
+                pages_data.append({
+                    "num": idx + 1,
+                    "time": f"{aligned_data[idx]['start_time']:.1f}s - {aligned_data[idx]['end_time']:.1f}s",
+                    "image": f"data:image/jpeg;base64,{img_data}",
+                    "text": SummaryGenerator.optimize_text(aligned_data[idx]["text"])
+                })
+
+            env = Environment()
+            template = env.from_string("""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <title>PPT视频摘要报告</title>
+                <style>
+                    .page { margin: 20px; padding: 15px; border: 1px solid #eee; }
+                    img { max-width: 800px; height: auto; }
+                    .timestamp { color: #666; font-size: 0.9em; }
+                    .content { margin-top: 10px; }
+                </style>
+            </head>
+            <body>
+                <h1>PPT视频结构化摘要</h1>
+                {% for page in pages %}
+                <div class="page">
+                    <h2>页面 {{ page.num }}</h2>
+                    <div class="timestamp">{{ page.time }}</div>
+                    <img src="{{ page.image }}" alt="页面截图">
+                    <div class="content">{{ page.text }}</div>
+                </div>
+                {% endfor %}
+            </body>
+            </html>
+            """)
+
+            output_path = os.path.join(output_dir, "summary.html")
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(template.render(pages=pages_data))
+            print(f"[输出] HTML报告已生成: {output_path}")
+        finally:
+            for f in os.listdir(temp_img_dir):
+                os.remove(os.path.join(temp_img_dir, f))
+            os.rmdir(temp_img_dir)
+
+    @staticmethod
+    def generate_pdf(aligned_data: list, keyframes: list, output_dir: str):
+        """生成PDF报告（优化版）"""
+        temp_html = os.path.join(output_dir, "_temp_pdf.html")
+        temp_img_dir = os.path.join(output_dir, "_temp_pdf_images")
+        os.makedirs(temp_img_dir, exist_ok=True)
+
+        try:
+            # 使用绝对路径
+            abs_temp_img_dir = os.path.abspath(temp_img_dir)
+
+            html_content = """
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <style>
+                    @page { 
+                        margin: 20mm;
+                        size: A4;
+                    }
+                    body {
+                        font-family: "Microsoft YaHei", "SimSun", sans-serif;
+                        line-height: 1.6;
+                        color: #333;
+                    }
+                    .page {
+                        page-break-inside: avoid;
+                        margin-bottom: 30px;
+                        padding: 20px;
+                        border: 1px solid #eee;
+                        border-radius: 5px;
+                    }
+                    .page-number {
+                        text-align: center;
+                        font-size: 24pt;
+                        font-weight: bold;
+                        margin-bottom: 20px;
+                        color: #2c3e50;
+                    }
+                    .timestamp {
+                        color: #666;
+                        font-size: 12pt;
+                        margin-bottom: 15px;
+                    }
+                    .image-container {
+                        text-align: center;
+                        margin: 20px 0;
+                    }
+                    img {
+                        max-width: 90% !important;
+                        height: auto;
+                        display: block;
+                        margin: 0 auto;
+                        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+                    }
+                    .content {
+                        font-size: 14pt;
+                        line-height: 1.8;
+                        margin-top: 20px;
+                        padding: 15px;
+                        background: #f9f9f9;
+                        border-radius: 5px;
+                    }
+                    .professional-term {
+                        color: #2980b9;
+                        font-weight: bold;
+                    }
+                </style>
+            </head>
+            <body>
+                <h1 style="text-align: center; color: #2c3e50; margin-bottom: 40px;">PPT视频结构化摘要</h1>
+                {% for page in pages %}
+                <div class="page">
+                    <div class="page-number">第 {{ page.num }} 页</div>
+                    <div class="timestamp">时间区间：{{ page.time }}</div>
+                    <div class="image-container">
+                        <img src="{{ page.image_path }}" alt="页面截图">
+                    </div>
+                    <div class="content">{{ page.text }}</div>
+                </div>
+                {% endfor %}
+            </body>
+            </html>
+            """
+
+            pages_data = []
+            for idx, frame in enumerate(keyframes):
+                img_filename = f"page_{idx}.jpg"
+                img_path = os.path.join(abs_temp_img_dir, img_filename)
+                frame.save(img_path)
+                pages_data.append({
+                    "num": idx + 1,
+                    "time": f"{aligned_data[idx]['start_time']:.1f}s - {aligned_data[idx]['end_time']:.1f}s",
+                    "image_path": img_path,
+                    "text": SummaryGenerator.optimize_text(aligned_data[idx]["text"])
+                })
+
+            env = Environment()
+            template = env.from_string(html_content)
+            with open(temp_html, "w", encoding="utf-8") as f:
+                f.write(template.render(pages=pages_data))
+
+            # PDF生成选项
+            options = {
+                "enable-local-file-access": "",
+                "encoding": "UTF-8",
+                "margin-top": "20mm",
+                "margin-bottom": "20mm",
+                "margin-left": "20mm",
+                "margin-right": "20mm",
+                "no-stop-slow-scripts": "",
+                "quiet": "",
+                "dpi": "300",
+                "image-quality": "100",
+                "enable-smart-shrinking": "",
+                "print-media-type": ""
+            }
+            config = pdfkit.configuration(wkhtmltopdf=WKHTMLTOPDF_PATH)
+
+            pdf_path = os.path.join(output_dir, "summary.pdf")
+            pdfkit.from_file(
+                temp_html,
+                pdf_path,
+                configuration=config,
+                options=options
+            )
+            print(f"[输出] PDF报告已生成: {pdf_path}")
+
+        finally:
+            # 清理临时文件
+            if os.path.exists(temp_html):
+                os.remove(temp_html)
+            if os.path.exists(temp_img_dir):
+                for f in os.listdir(temp_img_dir):
+                    os.remove(os.path.join(temp_img_dir, f))
+                os.rmdir(temp_img_dir)
+
+    @classmethod
+    def generate_all(cls, aligned_data: list, keyframes: list, output_dir: str):
+        """生成所有格式报告"""
+        cls.generate_html(aligned_data, keyframes, output_dir)
+        cls.generate_pdf(aligned_data, keyframes, output_dir)
+
+
+# ---------------------- 主流程控制 ----------------------
+def main_process():
+    # 环境检查
+    processor = VideoProcessor()
+    if not processor.check_ffmpeg():
+        return
+    if not os.path.exists(VIDEO_PATH):
+        print(f"[错误] 视频文件不存在: {VIDEO_PATH}")
+        return
+
+    # 关键帧提取
+    keyframes, timestamps = processor.extract_keyframes(VIDEO_PATH)
+    if not keyframes:
+        print("[错误] 未提取到关键帧")
+        return
+
+    # 内容对齐
+    aligned_data = ContentAligner.align_content(VIDEO_PATH, timestamps)
+    if not aligned_data:
+        print("[警告] 未识别到有效语音内容")
+
+    # 生成摘要
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    SummaryGenerator.generate_all(aligned_data, keyframes, OUTPUT_DIR)
+
+
+if __name__ == "__main__":
+    main_process()

6.0/毕设.py

@@ -0,0 +1,575 @@
+import os
+import re
+import base64
+import warnings
+import imageio
+import whisper
+import numpy as np
+import pdfkit
+from PIL import Image
+from skimage.metrics import structural_similarity as ssim
+from collections import defaultdict
+import subprocess
+from jinja2 import Environment
+import cv2
+from scipy.signal import find_peaks
+from skimage.feature import hog
+from skimage.color import rgb2gray
+
+# ======================== 全局配置 ========================
+warnings.filterwarnings("ignore", message="FP16 is not supported on CPU; using FP32 instead")
+VIDEO_PATH = "D:/python项目文件/1/input.mp4"  # 输入视频路径
+MODEL_DIR = "D:/whisper_models"  # Whisper模型目录
+FFMPEG_BIN = r"D:\Program Files\ffmpeg\bin"  # FFmpeg安装路径
+WKHTMLTOPDF_PATH = r"D:\wkhtmltopdf\bin\wkhtmltopdf.exe"  # wkhtmltopdf路径
+SSIM_THRESHOLD = 0.85  # 关键帧去重阈值
+FRAME_INTERVAL = 2  # 抽帧间隔（秒）
+OUTPUT_DIR = "D:\桌面文件\python\output"  # 输出目录
+TRANSITION_WORDS = ["接下来", "下一页", "如图"]  # 过渡词过滤列
+HOG_THRESHOLD = 0.7  # HOG特征相似度阈值
+COLOR_THRESHOLD = 0.8  # 颜色直方图相似度阈值
+WHISPER_MODEL = "base"  # Whisper模型大小
+PROFESSIONAL_TERMS = {
+    "人工智能": "AI",
+    "机器学习": "ML",
+    "深度学习": "DL",
+    "神经网络": "NN",
+    "卷积神经网络": "CNN",
+    "循环神经网络": "RNN",
+    "自然语言处理": "NLP",
+    "计算机视觉": "CV",
+    "大数据": "Big Data",
+    "云计算": "Cloud Computing"
+}  # 专业术语词典
+
+
+# ========================================================
+
+# ---------------------- 核心功能模块 ----------------------
+class VideoProcessor:
+    def __init__(self):
+        os.environ["PATH"] = FFMPEG_BIN + os.pathsep + os.environ["PATH"]
+
+    @staticmethod
+    def check_ffmpeg():
+        """验证FFmpeg可用性"""
+        try:
+            subprocess.run(["ffmpeg", "-version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            print("[系统] FFmpeg验证成功")
+            return True
+        except Exception as e:
+            print(f"[错误] FFmpeg验证失败: {str(e)}")
+            return False
+
+    @staticmethod
+    def calculate_color_histogram(frame):
+        """计算颜色直方图特征"""
+        hist = cv2.calcHist([frame], [0, 1, 2], None, [8, 8, 8], [0, 256, 0, 256, 0, 256])
+        cv2.normalize(hist, hist)
+        return hist.flatten()
+
+    @staticmethod
+    def calculate_hog_features(frame):
+        """计算HOG特征"""
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        features = hog(gray, orientations=8, pixels_per_cell=(16, 16),
+                       cells_per_block=(1, 1), visualize=False)
+        return features
+
+    @staticmethod
+    def is_ppt_transition(frame1, frame2):
+        """检测PPT页面切换"""
+        # 转换为灰度图
+        gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+        gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
+
+        # 计算边缘
+        edges1 = cv2.Canny(gray1, 100, 200)
+        edges2 = cv2.Canny(gray2, 100, 200)
+
+        # 计算边缘差异
+        diff = cv2.absdiff(edges1, edges2)
+        return np.mean(diff) > 50  # 阈值可调整
+
+    @staticmethod
+    def extract_keyframes(video_path: str) -> tuple:
+        """提取去重关键帧及其时间戳（多特征融合）"""
+        try:
+            reader = imageio.get_reader(video_path)
+            fps = reader.get_meta_data()["fps"]
+            total_frames = reader.count_frames()
+            print(f"[信息] 视频总帧数: {total_frames}")
+
+            keyframes = []
+            timestamps = []
+            prev_frame = None
+            frame_count = 0
+            last_progress = 0
+
+            for idx, frame in enumerate(reader):
+                # 显示进度
+                progress = int((idx / total_frames) * 100)
+                if progress != last_progress and progress % 5 == 0:  # 每5%显示一次进度
+                    print(f"[进度] 处理中: {progress}% ({idx}/{total_frames}帧)")
+                    last_progress = progress
+
+                curr_time = idx / fps
+                if curr_time - (timestamps[-1] if timestamps else 0) < FRAME_INTERVAL:
+                    continue
+
+                # 检查是否为无信息帧（纯黑屏或纯白屏）
+                if VideoProcessor.is_blank_frame(frame):
+                    continue
+
+                # 多特征相似度计算
+                if prev_frame is not None:
+                    try:
+                        # 1. SSIM相似度（使用简化版本）
+                        gray_prev = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
+                        gray_curr = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                        ssim_score = ssim(gray_prev, gray_curr, win_size=3)
+
+                        # 2. 颜色直方图相似度
+                        hist_prev = VideoProcessor.calculate_color_histogram(prev_frame)
+                        hist_curr = VideoProcessor.calculate_color_histogram(frame)
+                        color_sim = cv2.compareHist(hist_prev, hist_curr, cv2.HISTCMP_CORREL)
+
+                        # 3. HOG特征相似度（仅在SSIM和颜色相似度较高时计算）
+                        if ssim_score > 0.8 and color_sim > 0.8:
+                            hog_prev = VideoProcessor.calculate_hog_features(prev_frame)
+                            hog_curr = VideoProcessor.calculate_hog_features(frame)
+                            hog_sim = np.dot(hog_prev, hog_curr) / (np.linalg.norm(hog_prev) * np.linalg.norm(hog_curr))
+                        else:
+                            hog_sim = 0  # 如果SSIM和颜色相似度低，直接跳过HOG计算
+
+                        # 4. PPT页面切换检测
+                        is_transition = VideoProcessor.is_ppt_transition(prev_frame, frame)
+
+                        # 综合判断
+                        if (ssim_score > SSIM_THRESHOLD and
+                                color_sim > COLOR_THRESHOLD and
+                                hog_sim > HOG_THRESHOLD and
+                                not is_transition):
+                            continue
+                    except Exception as e:
+                        print(f"[警告] 特征计算失败: {str(e)}")
+                        continue
+
+                keyframes.append(Image.fromarray(frame))
+                timestamps.append(curr_time)
+                prev_frame = frame
+                frame_count += 1
+
+                # 每处理100帧强制垃圾回收
+                if frame_count % 100 == 0:
+                    import gc
+                    gc.collect()
+
+            reader.close()
+            print(f"[图像] 关键帧提取完成，共{len(keyframes)}帧")
+            return keyframes, timestamps
+        except Exception as e:
+            print(f"[错误] 关键帧提取失败: {str(e)}")
+            return [], []
+
+    @staticmethod
+    def is_blank_frame(frame, threshold=30):
+        """检测是否为无信息帧（纯黑屏或纯白屏）"""
+        try:
+            # 转换为灰度图
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+            # 计算图像统计特征
+            mean = np.mean(gray)
+            std_dev = np.std(gray)
+
+            # 检查是否为纯黑或纯白
+            is_black = mean < 10 and std_dev < 5
+            is_white = mean > 245 and std_dev < 5
+
+            # 检查是否有足够的细节
+            has_detail = std_dev > threshold
+
+            return is_black or is_white or not has_detail
+        except Exception as e:
+            print(f"[警告] 检查无信息帧时出错: {str(e)}")
+            return True
+
+    @staticmethod
+    def transcribe_audio(video_path: str, model_name: str = WHISPER_MODEL) -> list:
+        """语音识别与时间戳获取（支持中英文混合）"""
+        try:
+            # 使用更大的模型提高准确率
+            model = whisper.load_model(model_name, device="cpu", download_root=MODEL_DIR)
+
+            # 配置转写参数
+            result = model.transcribe(
+                video_path,
+                fp16=False,
+                language="zh",
+                task="transcribe",
+                verbose=True,
+                initial_prompt="这是一段包含中英文的PPT讲解视频，可能包含专业术语。"
+            )
+
+            segments = result.get("segments", [])
+
+            # 后处理：专业术语替换
+            for seg in segments:
+                text = seg["text"]
+                for cn, en in PROFESSIONAL_TERMS.items():
+                    text = text.replace(cn, f"{cn}({en})")
+                seg["text"] = text
+
+            return segments
+        except Exception as e:
+            print(f"[错误] 语音识别失败: {str(e)}")
+            return []
+
+
+# ---------------------- 业务逻辑模块 ----------------------
+class ContentAligner:
+    @staticmethod
+    def generate_page_intervals(timestamps: list, duration: float) -> list:
+        """生成页面时间段"""
+        intervals = []
+        for i in range(len(timestamps)):
+            start = timestamps[i]
+            end = timestamps[i + 1] if i < len(timestamps) - 1 else duration
+            intervals.append((start, end))
+        return intervals
+
+    @staticmethod
+    def calculate_text_similarity(text1: str, text2: str) -> float:
+        """计算文本相似度"""
+        # 使用简单的词重叠度计算
+        words1 = set(re.findall(r'\w+', text1.lower()))
+        words2 = set(re.findall(r'\w+', text2.lower()))
+        if not words1 or not words2:
+            return 0.0
+        intersection = words1.intersection(words2)
+        union = words1.union(words2)
+        return len(intersection) / len(union)
+
+    @staticmethod
+    def find_best_match(segments: list, intervals: list) -> dict:
+        """为每个语音片段找到最佳匹配的页面"""
+        page_texts = defaultdict(list)
+        unmatched_segments = []
+
+        for seg in segments:
+            seg_start = seg["start"]
+            best_match = None
+            best_score = 0.0
+
+            # 1. 首先尝试时间戳匹配
+            for page_idx, (start, end) in enumerate(intervals):
+                if start <= seg_start < end:
+                    best_match = page_idx
+                    break
+
+            # 2. 如果时间戳匹配失败，尝试文本相似度匹配
+            if best_match is None:
+                for page_idx, (start, end) in enumerate(intervals):
+                    # 获取该页面的所有文本
+                    page_text = " ".join([s["text"] for s in segments if start <= s["start"] < end])
+                    similarity = ContentAligner.calculate_text_similarity(seg["text"], page_text)
+                    if similarity > best_score:
+                        best_score = similarity
+                        best_match = page_idx
+
+            # 3. 如果找到匹配，添加到对应页面
+            if best_match is not None:
+                page_texts[best_match].append(seg)
+            else:
+                unmatched_segments.append(seg)
+
+        # 4. 处理未匹配的片段
+        if unmatched_segments:
+            print(f"[警告] 发现{len(unmatched_segments)}个未匹配的语音片段")
+            # 将未匹配片段添加到最近的页面
+            for seg in unmatched_segments:
+                closest_page = min(range(len(intervals)),
+                                   key=lambda i: abs(seg["start"] - (intervals[i][0] + intervals[i][1]) / 2))
+                page_texts[closest_page].append(seg)
+
+        return page_texts
+
+    @staticmethod
+    def align_content(video_path: str, timestamps: list) -> list:
+        """语音-画面对齐主逻辑（改进版）"""
+        try:
+            reader = imageio.get_reader(video_path)
+            duration = reader.get_meta_data()["duration"]
+            reader.close()
+        except:
+            duration = timestamps[-1] + FRAME_INTERVAL
+
+        segments = VideoProcessor.transcribe_audio(video_path)
+        intervals = ContentAligner.generate_page_intervals(timestamps, duration)
+
+        # 使用改进的匹配算法
+        page_texts = ContentAligner.find_best_match(segments, intervals)
+
+        # 生成最终的对齐数据
+        aligned_data = []
+        for idx in range(len(intervals)):
+            text = " ".join([seg["text"] for seg in page_texts.get(idx, [])])
+            aligned_data.append({
+                "page": idx,
+                "start_time": intervals[idx][0],
+                "end_time": intervals[idx][1],
+                "text": text
+            })
+
+        return aligned_data
+
+
+# ---------------------- 摘要生成模块 ----------------------
+class SummaryGenerator:
+    @staticmethod
+    def optimize_text(text: str) -> str:
+        """文本浓缩优化"""
+        sentences = re.split(r'[。！？]', text)
+        filtered = []
+        seen = set()
+        for sent in sentences:
+            sent = sent.strip()
+            if (len(sent) >= 10
+                    and not any(word in sent for word in TRANSITION_WORDS)
+                    and sent not in seen):
+                filtered.append(sent)
+                seen.add(sent)
+        return '。'.join(filtered) + '。' if filtered else ""
+
+    @staticmethod
+    def generate_html(aligned_data: list, keyframes: list, output_dir: str):
+        """生成HTML报告"""
+        pages_data = []
+        temp_img_dir = os.path.join(output_dir, "_temp_images")
+        os.makedirs(temp_img_dir, exist_ok=True)
+
+        try:
+            for idx, frame in enumerate(keyframes):
+                img_path = os.path.join(temp_img_dir, f"page_{idx}.jpg")
+                frame.save(img_path)
+                with open(img_path, "rb") as f:
+                    img_data = base64.b64encode(f.read()).decode("utf-8")
+
+                pages_data.append({
+                    "num": idx + 1,
+                    "time": f"{aligned_data[idx]['start_time']:.1f}s - {aligned_data[idx]['end_time']:.1f}s",
+                    "image": f"data:image/jpeg;base64,{img_data}",
+                    "text": SummaryGenerator.optimize_text(aligned_data[idx]["text"])
+                })
+
+            env = Environment()
+            template = env.from_string("""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <title>PPT视频摘要报告</title>
+                <style>
+                    .page { margin: 20px; padding: 15px; border: 1px solid #eee; }
+                    img { max-width: 800px; height: auto; }
+                    .timestamp { color: #666; font-size: 0.9em; }
+                    .content { margin-top: 10px; }
+                </style>
+            </head>
+            <body>
+                <h1>PPT视频结构化摘要</h1>
+                {% for page in pages %}
+                <div class="page">
+                    <h2>页面 {{ page.num }}</h2>
+                    <div class="timestamp">{{ page.time }}</div>
+                    <img src="{{ page.image }}" alt="页面截图">
+                    <div class="content">{{ page.text }}</div>
+                </div>
+                {% endfor %}
+            </body>
+            </html>
+            """)
+
+            output_path = os.path.join(output_dir, "summary.html")
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(template.render(pages=pages_data))
+            print(f"[输出] HTML报告已生成: {output_path}")
+        finally:
+            for f in os.listdir(temp_img_dir):
+                os.remove(os.path.join(temp_img_dir, f))
+            os.rmdir(temp_img_dir)
+
+    @staticmethod
+    def generate_pdf(aligned_data: list, keyframes: list, output_dir: str):
+        """生成PDF报告（优化版）"""
+        temp_html = os.path.join(output_dir, "_temp_pdf.html")
+        temp_img_dir = os.path.join(output_dir, "_temp_pdf_images")
+        os.makedirs(temp_img_dir, exist_ok=True)
+
+        try:
+            # 使用绝对路径
+            abs_temp_img_dir = os.path.abspath(temp_img_dir)
+
+            html_content = """
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <meta charset="UTF-8">
+                <style>
+                    @page { 
+                        margin: 20mm;
+                        size: A4;
+                    }
+                    body {
+                        font-family: "Microsoft YaHei", "SimSun", sans-serif;
+                        line-height: 1.6;
+                        color: #333;
+                    }
+                    .page {
+                        page-break-inside: avoid;
+                        margin-bottom: 30px;
+                        padding: 20px;
+                        border: 1px solid #eee;
+                        border-radius: 5px;
+                    }
+                    .page-number {
+                        text-align: center;
+                        font-size: 24pt;
+                        font-weight: bold;
+                        margin-bottom: 20px;
+                        color: #2c3e50;
+                    }
+                    .timestamp {
+                        color: #666;
+                        font-size: 12pt;
+                        margin-bottom: 15px;
+                    }
+                    .image-container {
+                        text-align: center;
+                        margin: 20px 0;
+                    }
+                    img {
+                        max-width: 90% !important;
+                        height: auto;
+                        display: block;
+                        margin: 0 auto;
+                        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+                    }
+                    .content {
+                        font-size: 14pt;
+                        line-height: 1.8;
+                        margin-top: 20px;
+                        padding: 15px;
+                        background: #f9f9f9;
+                        border-radius: 5px;
+                    }
+                    .professional-term {
+                        color: #2980b9;
+                        font-weight: bold;
+                    }
+                </style>
+            </head>
+            <body>
+                <h1 style="text-align: center; color: #2c3e50; margin-bottom: 40px;">PPT视频结构化摘要</h1>
+                {% for page in pages %}
+                <div class="page">
+                    <div class="page-number">第 {{ page.num }} 页</div>
+                    <div class="timestamp">时间区间：{{ page.time }}</div>
+                    <div class="image-container">
+                        <img src="{{ page.image_path }}" alt="页面截图">
+                    </div>
+                    <div class="content">{{ page.text }}</div>
+                </div>
+                {% endfor %}
+            </body>
+            </html>
+            """
+
+            pages_data = []
+            for idx, frame in enumerate(keyframes):
+                img_filename = f"page_{idx}.jpg"
+                img_path = os.path.join(abs_temp_img_dir, img_filename)
+                frame.save(img_path)
+                pages_data.append({
+                    "num": idx + 1,
+                    "time": f"{aligned_data[idx]['start_time']:.1f}s - {aligned_data[idx]['end_time']:.1f}s",
+                    "image_path": img_path,
+                    "text": SummaryGenerator.optimize_text(aligned_data[idx]["text"])
+                })
+
+            env = Environment()
+            template = env.from_string(html_content)
+            with open(temp_html, "w", encoding="utf-8") as f:
+                f.write(template.render(pages=pages_data))
+
+            # PDF生成选项
+            options = {
+                "enable-local-file-access": "",
+                "encoding": "UTF-8",
+                "margin-top": "20mm",
+                "margin-bottom": "20mm",
+                "margin-left": "20mm",
+                "margin-right": "20mm",
+                "no-stop-slow-scripts": "",
+                "quiet": "",
+                "dpi": "300",
+                "image-quality": "100",
+                "enable-smart-shrinking": "",
+                "print-media-type": ""
+            }
+            config = pdfkit.configuration(wkhtmltopdf=WKHTMLTOPDF_PATH)
+
+            pdf_path = os.path.join(output_dir, "summary.pdf")
+            pdfkit.from_file(
+                temp_html,
+                pdf_path,
+                configuration=config,
+                options=options
+            )
+            print(f"[输出] PDF报告已生成: {pdf_path}")
+
+        finally:
+            # 清理临时文件
+            if os.path.exists(temp_html):
+                os.remove(temp_html)
+            if os.path.exists(temp_img_dir):
+                for f in os.listdir(temp_img_dir):
+                    os.remove(os.path.join(temp_img_dir, f))
+                os.rmdir(temp_img_dir)
+
+    @classmethod
+    def generate_all(cls, aligned_data: list, keyframes: list, output_dir: str):
+        """生成所有格式报告"""
+        cls.generate_html(aligned_data, keyframes, output_dir)
+        cls.generate_pdf(aligned_data, keyframes, output_dir)
+
+
+# ---------------------- 主流程控制 ----------------------
+def main_process():
+    # 环境检查
+    processor = VideoProcessor()
+    if not processor.check_ffmpeg():
+        return
+    if not os.path.exists(VIDEO_PATH):
+        print(f"[错误] 视频文件不存在: {VIDEO_PATH}")
+        return
+
+    # 关键帧提取
+    keyframes, timestamps = processor.extract_keyframes(VIDEO_PATH)
+    if not keyframes:
+        print("[错误] 未提取到关键帧")
+        return
+
+    # 内容对齐
+    aligned_data = ContentAligner.align_content(VIDEO_PATH, timestamps)
+    if not aligned_data:
+        print("[警告] 未识别到有效语音内容")
+
+    # 生成摘要
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    SummaryGenerator.generate_all(aligned_data, keyframes, OUTPUT_DIR)
+
+
+if __name__ == "__main__":
+    main_process()

dockerfile.example

@@ -0,0 +1,44 @@
+# 1. 选择基础镜像 (推荐使用具体的版本号)
+FROM python:3.10
+
+# 2. 设置工作目录
+WORKDIR /app
+
+# 3. 更新apt包列表并安装系统依赖
+#    - build-essential: 用于编译一些Python包可能需要的C/C++代码
+#    - ffmpeg: 被 moviepy 和 imageio-ffmpeg 需要
+#    - libgl1-mesa-glx, libglib2.0-0: opencv-python 可能需要的运行时库
+#    - wkhtmltopdf: pdfkit 需要的工具
+#    --no-install-recommends 减少不必要的包安装
+#    最后清理 apt 缓存以减小镜像体积
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
+    ffmpeg \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    wkhtmltopdf \
+    && rm -rf /var/lib/apt/lists/*
+
+# 4. (推荐) 将你的 requirements.txt 文件复制到镜像中
+#    先复制 requirements.txt 并安装依赖，可以利用 Docker 的层缓存机制
+#    只有当 requirements.txt 改变时，这一层及之后的层才会重新构建
+COPY requirements.txt .
+
+# 5. 安装 Python 依赖
+#    --no-cache-dir 减少镜像体积
+#    -r requirements.txt 从文件安装
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 6. 复制你的 Flask 应用代码到镜像中
+COPY . .
+
+# 7. 声明你的 Flask 应用监听的端口 (默认是 5000)
+EXPOSE 5000
+
+# 8. 定义容器启动时运行的命令
+#    使用 Gunicorn 或 uWSGI 在生产环境中通常更好，但对于开发，flask run 也可以
+#    确保 Flask 监听 0.0.0.0 以便从容器外部访问
+CMD ["flask", "run", "--host=0.0.0.0"]
+# 或者如果你的启动文件是 app.py:
+# CMD ["python", "app.py"]

requirements.txt

@@ -0,0 +1,14 @@
+numpy>=1.21.0
+opencv-python>=4.5.3
+Pillow>=8.3.1
+imageio>=2.9.0
+imageio-ffmpeg>=0.4.5
+scikit-image>=0.18.3
+scipy>=1.7.1
+openai-whisper>=20231117
+pdfkit>=1.0.0
+Jinja2>=3.0.1
+moviepy>=1.0.3
+reportlab>=3.6.8
+torch>=1.9.0
+tqdm>=4.62.3 

完整框架/启动服务.bat

@@ -0,0 +1,7 @@
+@echo off
+echo 正在启动视频批量处理系统...
+start "" python server.py
+timeout /t 3
+start http://localhost:5000
+echo 服务已启动，如果浏览器没有自动打开，请手动访问 http://localhost:5000
+pause