doc-etl/cxs/cxs_doc_cleaner.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import os
import re
import docx
import numpy as np
import requests
import shutil
import subprocess
import tempfile
import time
import uuid  # 添加uuid模块导入
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from typing import List, Tuple, Dict, Optional, Any
from docx.shared import Pt
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
from docx.enum.table import WD_TABLE_ALIGNMENT
import json
from docx.table import _Cell
from docx.text.paragraph import Paragraph
from copy import deepcopy
from docx.oxml import parse_xml
from docx.oxml.ns import nsdecls
from bs4 import BeautifulSoup
import pandas as pd
import html2text
import zipfile
import cv2
import pytesseract  # 显式导入pytesseract，确保可用
from cxs_pdf_cleaner import PdfProcessor
from table_processor import TableProcessor, Cell, Row, Table, TableData  # 使用新的表格处理器类

class DocCleaner:
    def __init__(
    self,
    ollama_host: str = "http://192.168.1.24:11434",
     tesseract_cmd: str = None):
        """
        初始化文档清理器

        Args:
            ollama_host: Ollama服务器地址
            tesseract_cmd: Tesseract可执行文件路径，默认为None（使用系统环境变量）
        """
        # 页眉页脚模式
        self.header_footer_patterns = [
            r'页码\s*\d+-\d+',  # 页码格式：页码1-1, 页码2-1等
            r'第\s*\d+\s*页\s*共\s*\d+\s*页',  # 中文页码（第X页共Y页）
            r'Page\s*\d+\s*of\s*\d+',  # 英文页码
        ]

        # 特殊符号模式
        self.special_char_patterns = [
            r'©\s*\d{4}.*?版权所有',  # 版权信息
            r'confidential',  # 机密标记
            r'draft|草稿',  # 草稿标记
            r'watermark',  # 水印标记
        ]

        # 附录和参考文献标题模式
        self.appendix_patterns = [
            r'^附录\s*[A-Za-z]?[\s:：]',
            r'^Appendix\s*[A-Za-z]?[\s:：]',
            r'^参考文献$',
            r'^References$',
            r'^Bibliography$'
        ]

        # 初始化TF-IDF向量化器
        self.vectorizer = TfidfVectorizer(
            min_df=1,
            stop_words='english'
        )

        self.ollama_host = ollama_host
        self.embedding_model = "bge-m3:latest"  # 使用nomic-embed-text模型进行文本嵌入

        # 设置pytesseract路径
        if tesseract_cmd:
            pytesseract.pytesseract.tesseract_cmd = tesseract_cmd
            print(f"已设置Tesseract OCR路径: {tesseract_cmd}")
        else:
            # 如果没有提供tesseract_cmd，尝试自动查找路径
            # 尝试几个常见的安装路径
            common_paths = [
                r"C:\Program Files\Tesseract-OCR\tesseract.exe",
                r"C:\Program Files (x86)\Tesseract-OCR\tesseract.exe",
                r"C:\Users\Public\Tesseract-OCR\tesseract.exe",
                # 添加环境变量中的tesseract
                os.environ.get("TESSERACT_CMD", "")
            ]

            # 检查哪个路径存在并可用
            for path in common_paths:
                if path and os.path.exists(path):
                    tesseract_cmd = path
                    pytesseract.pytesseract.tesseract_cmd = tesseract_cmd
                    print(f"自动找到Tesseract OCR路径: {tesseract_cmd}")
                    break
            
            # 验证Tesseract是否可用
            try:
                pytesseract.get_tesseract_version()
                print(f"Tesseract版本: {pytesseract.get_tesseract_version()}")
            except Exception as e:
                print(f"警告：Tesseract OCR可能未正确配置: {str(e)}")
                print("请确保已安装Tesseract OCR并设置正确的路径")

        # 初始化PDF处理器
        self.pdf_processor = PdfProcessor(tesseract_cmd)

        # 保存OCR结果的字典，键为文档路径，值为图片信息列表
        self.ocr_results = {}
        
        # 初始化表格处理器
        self.table_processor = TableProcessor()

    def _convert_doc_to_docx(self, doc_path: str) -> str:
        """
        将DOC文件转换为DOCX格式

        Args:
            doc_path: DOC文件路径

        Returns:
            str: 转换后的DOCX文件路径
        """
        print(f"\n开始转换DOC文件: {doc_path}")

        # 创建临时目录
        temp_dir = tempfile.mkdtemp()
        docx_path = os.path.join(
    temp_dir, os.path.splitext(
        os.path.basename(doc_path))[0] + '.docx')

        try:
            # 使用 LibreOffice 转换
            if os.name == 'nt':  # Windows
                soffice_path = r"C:\Program Files\LibreOffice\program\soffice.exe"
                if not os.path.exists(soffice_path):
                    soffice_path = r"C:\Program Files (x86)\LibreOffice\program\soffice.exe"
                if not os.path.exists(soffice_path):
                    raise FileNotFoundError("找不到 LibreOffice，请确保已安装")

                cmd = [
                    soffice_path,
                    '--headless',
                    '--convert-to',
                    'docx',
                    '--outdir',
                    temp_dir,
                    doc_path
                ]
            else:  # Linux/Unix
                cmd = [
                    'soffice',
                    '--headless',
                    '--convert-to',
                    'docx',
                    '--outdir',
                    temp_dir,
                    doc_path
                ]

            # 执行转换命令
            print(f"执行转换命令: {' '.join(cmd)}")
            result = subprocess.run(cmd, capture_output=True, text=True)

            if result.returncode != 0:
                raise Exception(f"转换失败: {result.stderr}")

            # 验证转换结果
            if not os.path.exists(docx_path):
                raise FileNotFoundError(f"转换后的文件不存在: {docx_path}")

            print(f"DOC转换完成: {docx_path}")
            return docx_path

        except Exception as e:
            print(f"DOC转换失败: {str(e)}")
            # 清理临时目录
            if os.path.exists(temp_dir):
                shutil.rmtree(temp_dir)
            raise

    def _convert_pdf_to_docx(self, pdf_path: str) -> str:
        """
        将pdf格式转换为docx格式

        Args:
            pdf_path: pdf文件路径

        Returns:
            str: 转换后的docx文件路径
        """
        print(f"\n开始将PDF转换为DOCX: {pdf_path}")

        try:
            # 使用PdfProcessor进行转换
            docx_path = self.pdf_processor.convert_pdf_to_docx(pdf_path)
            print(f"PDF转换完成: {docx_path}")
            return docx_path
        except Exception as e:
            raise Exception(f"转换PDF文件失败: {str(e)}")

    def _extract_and_ocr_images(self, docx_path: str, output_dir: str = None) -> List[Dict]:
        """
        从DOCX文件中提取图片并进行OCR处理
        
        Args:
            docx_path: DOCX文件路径
            output_dir: 输出目录路径
            
        Returns:
            List[Dict]: 图片信息列表，包含路径和OCR文本
        """
        print(f"\n开始从文档中提取图片并进行OCR: {docx_path}")
        
        if not output_dir:
            output_dir = os.path.join(os.path.dirname(docx_path), "images")
        
        # 确保输出目录存在
        os.makedirs(output_dir, exist_ok=True)
        print(f"输出目录: {output_dir}")
        
        # 创建调试目录
        debug_dir = os.path.join(output_dir, "debug")
        os.makedirs(debug_dir, exist_ok=True)
        print(f"调试目录: {debug_dir}")
        
        # 创建调试日志文件
        debug_log_path = os.path.join(debug_dir, "ocr_debug.log")
        print(f"调试日志将保存到: {debug_log_path}")
        
        image_info_list = []
        enhanced_image_info_list = []
        
        try:
            with open(debug_log_path, 'w', encoding='utf-8') as debug_log:
                debug_log.write(f"开始处理文档: {docx_path}\n")
                debug_log.write(f"输出目录: {output_dir}\n\n")
                
                try:
                    # 1. 首先尝试使用python-docx来读取图片
                    debug_log.write("方法1: 使用python-docx提取图片\n")
                    try:
                        doc = docx.Document(docx_path)
                        for rel in doc.part.rels.values():
                            if "image" in rel.reltype:
                                image_data = rel.target_part.blob
                                image_filename = rel.target_ref.split("/")[-1]
                                image_path = os.path.join(output_dir, image_filename)
                                
                                with open(image_path, "wb") as f:
                                    f.write(image_data)
                                image_info = {
                                    "path": image_path,
                                    "method": "python-docx"
                                }
                                image_info_list.append(image_info)
                                debug_log.write(f"提取图片: {image_path}\n")
                                
                    except Exception as e:
                        debug_log.write(f"python-docx方法失败: {str(e)}\n")
                    
                    # 2. 如果python-docx方法失败，尝试使用ZIP方法
                    if not image_info_list:
                        debug_log.write("\n方法2: 使用ZIP方法提取图片\n")
                        try:
                            with zipfile.ZipFile(docx_path) as docx_zip:
                                # 获取所有媒体文件
                                media_files = [f for f in docx_zip.namelist() if f.startswith("word/media/")]
                                
                                for media_file in media_files:
                                    try:
                                        file_data = docx_zip.read(media_file)
                                        file_name = os.path.basename(media_file)
                                        output_path = os.path.join(output_dir, file_name)
                                        
                                        with open(output_path, "wb") as f:
                                            f.write(file_data)
                                        
                                        image_info = {
                                            "path": output_path,
                                            "method": "zip"
                                        }
                                        image_info_list.append(image_info)
                                        debug_log.write(f"提取图片: {output_path}\n")
                                        
                                    except Exception as e:
                                        debug_log.write(f"提取 {media_file} 失败: {str(e)}\n")
                        except Exception as e:
                            debug_log.write(f"ZIP方法失败: {str(e)}\n")
                    
                    # 处理提取的图片
                    debug_log.write(f"\n共提取 {len(image_info_list)} 张图片\n")
                    
                    # 对每个图片进行OCR处理
                    for i, image_info in enumerate(image_info_list):
                        try:
                            image_path = image_info["path"]
                            debug_log.write(f"\n处理图片 {i+1}/{len(image_info_list)}: {image_path}\n")
                            
                            # 检查图片是否存在且有效
                            if not os.path.exists(image_path):
                                debug_log.write(f"错误：图片文件不存在\n")
                                continue
                            if not self.pdf_processor._is_valid_image(image_path):
                                debug_log.write(f"错误：无效的图片文件\n")
                                continue
                            
                            # 尝试OCR处理
                            ocr_text = None
                            max_attempts = 5
                            attempts = 0
                            
                            # 1. 首先尝试直接OCR
                            debug_log.write("方法1: 直接OCR\n")
                            try:
                                # 直接调用pytesseract进行OCR，而不是通过pdf_processor
                                try:
                                    # 确保pytesseract路径正确设置
                                    if pytesseract.pytesseract.tesseract_cmd and os.path.exists(pytesseract.pytesseract.tesseract_cmd):
                                        debug_log.write(f"使用Tesseract路径: {pytesseract.pytesseract.tesseract_cmd}\n")
                                    else:
                                        debug_log.write(f"警告: Tesseract路径未设置或不存在\n")
                                    
                                    # 直接使用pytesseract
                                    direct_text = pytesseract.image_to_string(image_path, lang='chi_sim+eng')
                                    if direct_text and direct_text.strip():
                                        ocr_text = direct_text
                                        debug_log.write(f"直接pytesseract OCR成功!\n")
                                    else:
                                        # 尝试使用pdf_processor
                                        ocr_text = self.pdf_processor.perform_ocr(image_path)
                                        debug_log.write(f"使用pdf_processor OCR {'成功' if ocr_text else '失败'}\n")
                                except Exception as pyt_err:
                                    debug_log.write(f"直接pytesseract调用失败: {str(pyt_err)}\n")
                                    # 如果直接调用失败，回退到pdf_processor
                                    try:
                                        ocr_text = self.pdf_processor.perform_ocr(image_path)
                                        debug_log.write(f"回退到pdf_processor OCR {'成功' if ocr_text else '失败'}\n")
                                    except Exception as pdf_err:
                                        debug_log.write(f"pdf_processor OCR也失败: {str(pdf_err)}\n")
                                
                                debug_log.write(f"直接OCR结果: {'成功' if ocr_text else '失败'}\n")
                                debug_log.write(f"文本长度: {len(ocr_text) if ocr_text else 0}\n")
                            except Exception as e:
                                debug_log.write(f"直接OCR失败: {str(e)}\n")
                            
                            # 2. 如果直接OCR失败，尝试中文优化
                            if not ocr_text:
                                debug_log.write("\n方法2: 中文优化OCR\n")
                                try:
                                    image = self.pdf_processor._read_image(image_path)
                                    if image is not None:
                                        # 保存原始读取的图像
                                        orig_np_path = os.path.join(debug_dir, f"orig_np_{i+1}.png")
                                        cv2.imwrite(orig_np_path, image)
                                        debug_log.write(f"保存原始numpy图像: {orig_np_path}\n")
                                        
                                        # 应用中文优化
                                        processed = self.pdf_processor._optimize_for_chinese(image)
                                        
                                        # 保存处理后的图像
                                        processed_path = os.path.join(debug_dir, f"chinese_opt_{i+1}.png")
                                        cv2.imwrite(processed_path, processed)
                                        debug_log.write(f"保存中文优化处理图像: {processed_path}\n")
                                        
                                        # 尝试直接使用pytesseract
                                        try:
                                            cn_ocr_text = pytesseract.image_to_string(processed_path, lang='chi_sim+eng')
                                            if cn_ocr_text and cn_ocr_text.strip():
                                                debug_log.write(f"中文优化pytesseract OCR成功!\n")
                                                ocr_text = cn_ocr_text
                                            else:
                                                # 如果直接调用失败，使用pdf_processor
                                                cn_ocr_text = self.pdf_processor.perform_ocr(processed_path)
                                                debug_log.write(f"中文优化pdf_processor OCR {'成功' if cn_ocr_text else '失败'}\n")
                                                if cn_ocr_text:
                                                    ocr_text = cn_ocr_text
                                        except Exception as cn_err:
                                            debug_log.write(f"中文优化pytesseract OCR失败: {str(cn_err)}\n")
                                            # 使用pdf_processor作为备选
                                            cn_ocr_text = self.pdf_processor.perform_ocr(processed_path)
                                            debug_log.write(f"中文优化OCR结果: {'成功' if cn_ocr_text else '失败'}\n")
                                            debug_log.write(f"文本长度: {len(cn_ocr_text) if cn_ocr_text else 0}\n")
                                            
                                            if cn_ocr_text:
                                                ocr_text = cn_ocr_text
                                    else:
                                        debug_log.write(f"无法读取图像进行中文优化\n")
                                except Exception as e:
                                    debug_log.write(f"中文优化OCR出错: {str(e)}\n")
                            
                            # 3. 如果前两种方法都失败，尝试多种预处理方法
                            if not ocr_text:
                                debug_log.write("\n方法3: 多种预处理方法\n")
                                try:
                                    image = self.pdf_processor._read_image(image_path)
                                    if image is not None:
                                        # 获取多种预处理结果
                                        preprocessed_images = self.pdf_processor._apply_multiple_preprocessing(image)
                                        
                                        for method_name, processed_image in preprocessed_images:
                                            attempts += 1
                                            debug_log.write(f"\n尝试 {attempts}/{max_attempts}: {method_name}\n")
                                            
                                            # 保存处理后的图像
                                            processed_path = os.path.join(debug_dir, f"prep_{method_name.replace(' ', '_')}_{i+1}.png")
                                            cv2.imwrite(processed_path, processed_image)
                                            debug_log.write(f"保存{method_name}处理图像: {processed_path}\n")
                                            
                                            # 尝试直接使用pytesseract
                                            try:
                                                prep_ocr_text = pytesseract.image_to_string(processed_path, lang='chi_sim+eng')
                                                if prep_ocr_text and prep_ocr_text.strip():
                                                    debug_log.write(f"预处理pytesseract OCR成功!\n")
                                                    ocr_text = prep_ocr_text
                                                    debug_log.write(f"已找到有效OCR结果，使用{method_name}方法\n")
                                                    break
                                                else:
                                                    # 执行OCR
                                                    prep_ocr_text = self.pdf_processor.perform_ocr(processed_path)
                                                    debug_log.write(f"{method_name} OCR结果: {'成功' if prep_ocr_text else '失败'}\n")
                                                    debug_log.write(f"文本长度: {len(prep_ocr_text) if prep_ocr_text else 0}\n")
                                                    
                                                    if prep_ocr_text:
                                                        ocr_text = prep_ocr_text
                                                        debug_log.write(f"已找到有效OCR结果，使用{method_name}方法\n")
                                                        break
                                            except Exception as prep_err:
                                                debug_log.write(f"预处理pytesseract OCR失败: {str(prep_err)}\n")
                                                try:
                                                    # 执行OCR
                                                    prep_ocr_text = self.pdf_processor.perform_ocr(processed_path)
                                                    debug_log.write(f"{method_name} OCR结果: {'成功' if prep_ocr_text else '失败'}\n")
                                                    debug_log.write(f"文本长度: {len(prep_ocr_text) if prep_ocr_text else 0}\n")
                                                    
                                                    if prep_ocr_text:
                                                        ocr_text = prep_ocr_text
                                                        debug_log.write(f"已找到有效OCR结果，使用{method_name}方法\n")
                                                        break
                                                except Exception as e:
                                                    debug_log.write(f"备用OCR也失败: {str(e)}\n")
                                            
                                        if attempts >= max_attempts:
                                            debug_log.write("达到最大尝试次数，停止处理\n")
                                            break
                                    else:
                                        debug_log.write(f"无法读取图像进行多种预处理\n")
                                except Exception as e:
                                    debug_log.write(f"多种预处理OCR出错: {str(e)}\n")
                            
                            # 更新图片信息
                            image_info["ocr_text"] = ocr_text
                            enhanced_image_info_list.append(image_info)
                            
                            # 记录处理结果
                            print(f"图片 {i+1} OCR处理完成，结果: {'成功' if ocr_text else '失败'}")
                            debug_log.write(f"最终OCR结果: {'成功' if ocr_text else '失败'}\n\n")
                        
                        except Exception as e:
                            error_msg = f"处理图片 {i+1} 时出错: {str(e)}"
                            print(error_msg)
                            debug_log.write(f"{error_msg}\n")
                            import traceback
                            debug_log.write(f"错误详情: {traceback.format_exc()}\n\n")
                            image_info["ocr_text"] = None
                            enhanced_image_info_list.append(image_info)
                    
                    # 保存OCR结果到缓存
                    self.ocr_results[docx_path] = enhanced_image_info_list
                    
                    return enhanced_image_info_list
                except Exception as e:
                    print(f"处理文档图片时出错: {str(e)}")
                    debug_log.write(f"处理文档图片时出错: {str(e)}\n")
                    import traceback
                    debug_log.write(f"错误详情: {traceback.format_exc()}\n")
                    return []
        except Exception as e:
            print(f"创建日志文件或处理图片时出错: {str(e)}")
            import traceback
            traceback.print_exc()
            return []

    def process_pdf(self, pdf_path: str, output_dir: str = None) -> Tuple[List[str], List[str], List[Table]]:
        """
        处理PDF文件：转换为DOCX，提取图片OCR，然后清理文档
        
        Args:
            pdf_path: PDF文件路径
            output_dir: 输出目录
            
        Returns:
            Tuple[List[str], List[str], List[Table]]: (清理后的正文段落列表, 附录段落列表, 表格列表)
        """
        # 确定输出目录
        if output_dir is None:
            output_dir = os.path.dirname(pdf_path)
            
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)
            
        try:
            print(f"\n开始处理PDF文件: {pdf_path}")
            
            # 步骤1: 直接从PDF提取图片（确保即使转换过程中丢失图片也能保留）
            pdf_images_dir = os.path.join(output_dir, f"pdf_images_{str(uuid.uuid4())[:8]}")
            os.makedirs(pdf_images_dir, exist_ok=True)
            pdf_extracted_images = self._extract_images_from_pdf(pdf_path, pdf_images_dir)
            
            if pdf_extracted_images:
                print(f"从PDF直接提取了 {len(pdf_extracted_images)} 张图片")
                # 先直接保存从PDF提取的图片信息，以防后续转换失败
                self.ocr_results[pdf_path] = pdf_extracted_images
                
            # 步骤2: 转换PDF为DOCX
            docx_path = self._convert_pdf_to_docx(pdf_path)
            
            # 步骤3: 提取图片并OCR
            # 使用标准化的temp/images路径存储图片
            from pathlib import Path
            import sys
            
            # 查找标准的temp/images目录
            TEMP_DIR = None
            # 获取当前文件所在目录
            current_dir = Path(os.path.dirname(os.path.abspath(__file__)))
            
            # 尝试找到项目根目录下的temp目录
            root_candidates = [
                current_dir,  # 当前目录
                current_dir.parent,  # 上一级目录
                Path.cwd()  # 当前工作目录
            ]
            
            for root_candidate in root_candidates:
                temp_candidate = root_candidate / "temp" / "images"
                if temp_candidate.exists():
                    TEMP_DIR = temp_candidate
                    print(f"找到已存在的图片目录: {TEMP_DIR}")
                    break
                elif (root_candidate / "temp").exists():
                    TEMP_DIR = temp_candidate
                    os.makedirs(TEMP_DIR, exist_ok=True)
                    print(f"在已存在的temp目录下创建图片目录: {TEMP_DIR}")
                    break
            
            # 如果还是没有找到，使用当前目录创建temp结构
            if TEMP_DIR is None:
                TEMP_DIR = current_dir / "temp" / "images"
                parent_dir = TEMP_DIR.parent
                os.makedirs(parent_dir, exist_ok=True)
                os.makedirs(TEMP_DIR, exist_ok=True)
                print(f"创建新的图片目录结构: {TEMP_DIR}")
            
            # 创建规范的图片目录名称（使用PDF文件名作为前缀）
            file_stem = Path(pdf_path).stem
            # 规范化文件名，移除不安全字符
            safe_file_stem = re.sub(r'[^\w\-_\.]', '_', file_stem)
            unique_id = str(uuid.uuid4())[:8]
            images_dir = TEMP_DIR / f"{safe_file_stem}_{unique_id}"
            os.makedirs(images_dir, exist_ok=True)
            print(f"创建图片专用目录: {images_dir}")
            
            # 提取图片并进行OCR
            extracted_images = self._extract_and_ocr_images(docx_path, str(images_dir))
            
            # 保存OCR结果以便后续处理
            if extracted_images:
                print(f"从DOCX提取到 {len(extracted_images)} 张图片")
                # 合并两种提取方法的结果
                self.ocr_results[docx_path] = extracted_images
                
                # 如果已经有从PDF直接提取的图片，则将DOCX提取的图片也添加到PDF路径下的ocr结果中
                if pdf_path in self.ocr_results:
                    self.ocr_results[pdf_path].extend(extracted_images)
                    print(f"合并后共有 {len(self.ocr_results[pdf_path])} 张图片")
            elif not pdf_extracted_images:
                # 如果两种方法都没有提取到图片，再尝试第三种方法
                print("两种方法都没有提取到图片，尝试使用第三种方法提取")
                try:
                    # 使用PDF处理器直接处理pdf_path
                    alt_images_dir = os.path.join(str(images_dir), "alt_method")
                    os.makedirs(alt_images_dir, exist_ok=True)
                    
                    # 使用process_pdf_with_ocr的替代方法
                    alt_result = self.pdf_processor.process_pdf_with_ocr(pdf_path, alt_images_dir)
                    if isinstance(alt_result, tuple) and len(alt_result) == 2:
                        _, image_info_list = alt_result
                        if image_info_list:
                            print(f"使用替代方法成功提取 {len(image_info_list)} 张图片")
                            self.ocr_results[docx_path] = image_info_list
                        else:
                            print("替代方法未能提取到图片")
                    else:
                        print(f"替代方法返回了意外的结果: {alt_result}")
                except Exception as alt_err:
                    print(f"使用替代方法提取图片失败: {str(alt_err)}")
            
            # 确保图片结果被正确复制到最终的缓存中
            key_to_use = None
            max_images = 0
            
            # 查找哪个键有最多的图片
            for key, images in self.ocr_results.items():
                if len(images) > max_images:
                    max_images = len(images)
                    key_to_use = key
            
            # 如果找到了有图片的键，确保docx_path也有这些图片
            if key_to_use and key_to_use != docx_path and max_images > 0:
                print(f"确保DOCX文件的缓存包含所有找到的图片 (从 {key_to_use} 复制 {max_images} 张图片)")
                self.ocr_results[docx_path] = self.ocr_results[key_to_use]
            
            # 步骤4: 使用现有清理逻辑处理DOCX
            return self.clean_doc(docx_path)
            
        except Exception as e:
            print(f"处理PDF文件失败: {str(e)}")
            raise

    def get_ocr_results(self, doc_path: str) -> List[Dict]:
        """
        获取文档的OCR处理结果
        
        Args:
            doc_path: 文档路径
            
        Returns:
            List[Dict]: OCR结果列表
        """
        return self.ocr_results.get(doc_path, [])

    def _convert_html_to_docx(self, html_path: str) -> str:
        """
        将HTML文件转换为DOCX格式
        
        Args:
            html_path: HTML文件路径
            
        Returns:
            str: 转换后的DOCX文件路径
        """
        print(f"\n开始将HTML转换为DOCX: {html_path}")
        
        # 创建临时目录
        temp_dir = tempfile.mkdtemp()
        docx_path = os.path.join(temp_dir, os.path.splitext(os.path.basename(html_path))[0] + '.docx')
        
        try:
            # 读取HTML内容
            with open(html_path, 'r', encoding='utf-8') as f:
                html_content = f.read()
            
            # 使用BeautifulSoup解析HTML
            soup = BeautifulSoup(html_content, 'html.parser')
            
            # 提取文本内容
            text_content = html2text.html2text(str(soup))
            
            # 创建新的Word文档
            doc = docx.Document()
            
            # 将文本内容添加到Word文档
            doc.add_paragraph(text_content)
            
            # 保存Word文档
            doc.save(docx_path)
            
            return docx_path
            
        except Exception as e:
            print(f"HTML转换失败: {str(e)}")
            raise

    def _convert_excel_to_docx(self, excel_path: str, max_rows: int = 1000, direct_process: bool = True) -> str:
        """
        将Excel文件转换为DOCX格式或直接提取内容
        
        Args:
            excel_path: Excel文件路径
            max_rows: 每个工作表最多处理的行数，默认1000行
            direct_process: 是否直接处理Excel而不转换为DOCX(True为直接处理)
            
        Returns:
            str: 转换后的DOCX文件路径，或者临时文件路径(如果直接处理)
        """
        print(f"\n开始处理Excel文件: {excel_path}")
        
        # 创建临时目录
        temp_dir = tempfile.mkdtemp()
        temp_file_path = os.path.join(temp_dir, os.path.splitext(os.path.basename(excel_path))[0] + '.txt')
        docx_path = os.path.join(temp_dir, os.path.splitext(os.path.basename(excel_path))[0] + '.docx')
        
        excel_file = None
        try:
            print(f"开始读取Excel文件...")
            # 创建ExcelFile对象，但不立即读取所有数据
            excel_file = pd.ExcelFile(excel_path)
            sheet_names = excel_file.sheet_names
            print(f"Excel文件包含 {len(sheet_names)} 个工作表")
            
            # 如果直接处理，创建一个文本文件存储内容
            if direct_process:
                with open(temp_file_path, 'w', encoding='utf-8') as f:
                    # 保存工作表内容到文本文件
                    extracted_text = []
                    
                    for sheet_name in sheet_names:
                        print(f"处理工作表: {sheet_name}")
                        f.write(f"\n# 工作表: {sheet_name}\n\n")
                        extracted_text.append(f"工作表: {sheet_name}")
                        
                        # 使用chunksize分批读取大型工作表
                        try:
                            # 尝试获取工作表的总行数来决定是否分批读取
                            df_info = pd.read_excel(excel_file, sheet_name=sheet_name, nrows=5)
                            total_rows = len(pd.read_excel(excel_file, sheet_name=sheet_name, nrows=None))
                            
                            if total_rows > max_rows:
                                print(f"  - 警告：工作表 {sheet_name} 行数过多 ({total_rows} > {max_rows})，将只读取前 {max_rows} 行")
                                f.write(f"警告：工作表行数过多，仅处理前 {max_rows} 行\n\n")
                                df = pd.read_excel(excel_file, sheet_name=sheet_name, nrows=max_rows)
                            else:
                                df = pd.read_excel(excel_file, sheet_name=sheet_name)
                            
                            if df.empty:
                                print(f"  - 工作表 {sheet_name} 为空")
                                extracted_text.append("此工作表为空")
                        except Exception as e:
                            error_msg = f"读取工作表 {sheet_name} 出错: {str(e)}"
                            print(f"  - {error_msg}")
                            f.write(f"{error_msg}\n\n")
                            extracted_text.append(error_msg)
                    
                # 同时创建一个简单的Word文档，确保后续处理不会出错
                doc = docx.Document()
                doc.add_heading(f"Excel文件: {os.path.basename(excel_path)}", 0)
                
                # 添加提取出的文本内容
                for text in extracted_text:
                    doc.add_paragraph(text)
                
                # 保存简单Word文档
                doc.save(docx_path)
                print(f"Excel内容已直接处理并保存为文本文件: {temp_file_path}")
                print(f"同时创建了简单Word文档: {docx_path}")
                
                # 将处理结果添加到OCR结果中，确保文本能在最终输出中显示
                self.ocr_results[docx_path] = [{
                    'path': temp_file_path,
                    'ocr_text': "\n".join(extracted_text),
                    'is_excel_content': True  # 标记这是Excel内容而非图片OCR
                }]
                
                # 显式关闭Excel文件
                if excel_file is not None:
                    excel_file.close()
                    excel_file = None
                    print("已显式关闭Excel文件连接")
                
                return docx_path
            
            # 如果不是直接处理，执行常规的Excel到Word转换
            print("开始将Excel转换为Word文档...")
            doc = docx.Document()
            
            # 处理每个工作表，但限制处理的行数
            for sheet_name in sheet_names:
                print(f"处理工作表: {sheet_name}")
                
                # 添加工作表标题
                doc.add_heading(f'工作表: {sheet_name}', level=1)
                
                try:
                    # 读取工作表数据，限制行数
                    df = pd.read_excel(excel_file, sheet_name=sheet_name, nrows=max_rows)
                    
                    # 输出表格行列信息
                    rows, cols = df.shape
                    print(f"  - 读取 {rows} 行 x {cols} 列数据")
                    
                    # 检查是否截断了数据
                    if rows >= max_rows:
                        print(f"  - 警告：行数超过限制({max_rows})，数据已截断")
                        doc.add_paragraph(f"注意：此工作表仅显示前 {max_rows} 行数据").italic = True
                    
                    if not df.empty:
                        # 创建表格，行数+1是为了表头行
                        if rows > 0 and cols > 0:
                            # 创建表格
                            table = doc.add_table(rows=min(rows, max_rows) + 1, cols=cols)
                            table.style = 'Table Grid'
                            
                            # 添加表头
                            for j, column in enumerate(df.columns):
                                cell = table.cell(0, j)
                                cell.text = str(column)
                                # 设置表头单元格格式
                                cell.paragraphs[0].runs[0].bold = True
                            
                            # 添加数据
                            for i, (_, row) in enumerate(df.iterrows()):
                                if i >= max_rows:
                                    break
                                for j, value in enumerate(row.values):
                                    table.cell(i + 1, j).text = str(value)
                    else:
                        doc.add_paragraph("此工作表为空")
                    
                    # 添加空行
                    doc.add_paragraph()
                    
                except Exception as e:
                    doc.add_paragraph(f"读取工作表 {sheet_name} 出错: {str(e)}")
                    print(f"  - 警告：读取工作表 {sheet_name} 出错: {str(e)}")
            
            # 保存文档
            doc.save(docx_path)
            print(f"Excel转换完成: {docx_path}")
            return docx_path
                        
        except Exception as e:
            print(f"Excel处理失败: {str(e)}")
            import traceback
            traceback.print_exc()
            
            # 创建一个错误提示文档
            error_doc = docx.Document()
            error_doc.add_heading("Excel处理失败", 0)
            error_doc.add_paragraph(f"处理文件 {excel_path} 时出错: {str(e)}")
            error_doc.save(docx_path)
            
            return docx_path
        finally:
            # 确保在所有情况下都关闭文件
            if excel_file is not None:
                try:
                    excel_file.close()
                    print("已在finally块中关闭Excel文件连接")
                except Exception as close_error:
                    print(f"关闭Excel文件时出错: {str(close_error)}")

    def clean_doc(self, file_path: str) -> Tuple[List[str], List[str], List[Table]]:
        """
        清理文档，提取其中的文本内容、附录和表格
        
        Args:
            file_path: 文件路径
            
        Returns:
            Tuple: (正文内容, 附录内容, 表格列表)
        """
        if not os.path.exists(file_path):
            raise FileNotFoundError(f"文件不存在: {file_path}")
        
        file_ext = os.path.splitext(file_path)[1].lower()
        
        print(f"\n开始处理文件: {file_path}")
        print(f"文件类型: {file_ext}")
        
        # 根据不同的文件类型进行处理
        if file_ext in ['.doc', '.docx']:
            # 如果是.doc格式，需要先转为.docx
            if file_ext == '.doc':
                print("\n检测到.doc格式，首先转换为.docx格式...")
                temp_docx = self._convert_doc_to_docx(file_path)
                print(f"转换完成: {temp_docx}")
                
                # 提取和处理图片
                print(f"\n开始提取并处理文档中的图片...")
                images_dir = os.path.join(os.path.dirname(temp_docx), "images_" + str(uuid.uuid4())[:8])
                print(f"图片将保存到目录: {images_dir}")
                extracted_images = self._extract_and_ocr_images(temp_docx, images_dir)
                print(f"共提取并处理了 {len(extracted_images)} 张图片，OCR结果缓存数量: {len(self.ocr_results.get(temp_docx, []))}")
            else:
                # 对于.docx格式，直接处理
                print("\n直接处理.docx格式文件...")
                temp_docx = file_path
                
                # 提取和处理图片
                print(f"\n开始提取并处理文档中的图片...")
                images_dir = os.path.join(os.path.dirname(temp_docx), "images_" + str(uuid.uuid4())[:8])
                print(f"图片将保存到目录: {images_dir}")
                extracted_images = self._extract_and_ocr_images(temp_docx, images_dir)
                print(f"共提取并处理了 {len(extracted_images)} 张图片，OCR结果缓存数量: {len(self.ocr_results.get(temp_docx, []))}")
            
            # 初始化结果
            main_content = []
            appendix_content = []
            tables = []
            
            try:
                # 加载并处理文档
                doc = docx.Document(temp_docx)
                
                # 添加文件元数据处理
                print("\n提取文档元数据...")
                try:
                    core_properties = doc.core_properties
                    if core_properties:
                        meta_info = []
                        if core_properties.title:
                            meta_info.append(f"标题: {core_properties.title}")
                        if core_properties.author:
                            meta_info.append(f"作者: {core_properties.author}")
                        if core_properties.created:
                            meta_info.append(f"创建时间: {core_properties.created}")
                        if core_properties.modified:
                            meta_info.append(f"修改时间: {core_properties.modified}")
                        if core_properties.subject:
                            meta_info.append(f"主题: {core_properties.subject}")
                        if core_properties.comments:
                            meta_info.append(f"备注: {core_properties.comments}")
                        
                        if meta_info:
                            # 添加元数据到内部结构，但标记为元数据类型，方便后续处理
                            main_content.append({"type": "metadata_header", "content": "【文档信息】"})
                            for meta_item in meta_info:
                                main_content.append({"type": "metadata", "content": meta_item})
                            main_content.append({"type": "metadata_separator", "content": ""})  # 添加空行分隔
                            print(f"已提取 {len(meta_info)} 项元数据信息")
                except Exception as e:
                    print(f"提取元数据出错: {str(e)}")
                
                # 首先提取所有段落和表格的位置信息，保持它们在文档中的相对顺序
                print("\n分析文档结构...")
                elements = []
                
                # 分析文档主体元素
                for idx, element in enumerate(doc.element.body):
                    if element.tag.endswith('tbl'):
                        elements.append(('table', idx))
                    elif element.tag.endswith('p'):
                        elements.append(('paragraph', idx))
                
                print(f"文档共包含 {len(elements)} 个元素")
                
                # 按顺序处理各个元素
                current_table_index = 0
                for element_type, element_idx in elements:
                    if element_type == 'table':
                        try:
                            element = doc.element.body[element_idx]
                            # 使用新的表格处理器处理表格
                            processed_table = self.table_processor.process_table(doc.tables[current_table_index])
                            
                            # 检查表格是否有效
                            if processed_table and processed_table.total_rows > 0:
                                tables.append(processed_table)
                                # 在正文中添加表格占位符
                                main_content.append(f"TABLE_PLACEHOLDER_{current_table_index}")
                                current_table_index += 1
                                print(f"处理表格 #{current_table_index}，行数: {processed_table.total_rows}, 列数: {processed_table.total_cols}")
                                
                                # 输出表格类型信息
                                print(f"表格类型: {processed_table.table_type}")
                                if processed_table.has_complex_header:
                                    print(f"复杂表头: 是，表头行数: {processed_table.header_rows}")
                            else:
                                # 如果表格无效，将其作为普通文本处理
                                print(f"发现无效表格，作为文本处理")
                                table_text = self.table_processor.convert_to_markdown(processed_table)
                                if table_text.strip():
                                    main_content.append(table_text)
                        except Exception as e:
                            print(f"处理表格时出错: {str(e)}")
                            import traceback
                            traceback.print_exc()
                    
                    elif element_type == 'paragraph':
                        try:
                            # 处理段落
                            element = doc.element.body[element_idx]
                            
                            # 尝试提取更完整的文本，包括所有运行对象
                            text_parts = []
                            for run in element.findall('.//w:t', namespaces={'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'}):
                                if run.text:
                                    text_parts.append(run.text)
                            
                            if text_parts:
                                paragraph_text = ''.join(text_parts)
                                if paragraph_text.strip():
                                    main_content.append(paragraph_text)
                            else:
                                # 如果没有找到文本，检查是否有其他类型的内容（如图表、公式等）
                                paragraph_obj = doc.paragraphs[element_idx]
                                if hasattr(paragraph_obj, 'text') and paragraph_obj.text.strip():
                                    main_content.append(paragraph_obj.text)
                        except Exception as e:
                            print(f"处理段落时出错: {str(e)}")
                
                # 使用提取的OCR结果
                if temp_docx in self.ocr_results and self.ocr_results[temp_docx]:
                    print(f"\n处理OCR结果...")
                    for ocr_info in self.ocr_results[temp_docx]:
                        ocr_text = ocr_info.get('ocr_text', '')
                        if ocr_text:
                            # 只有当OCR文本不为空时才添加
                            main_content.append(f"\n【图片识别文本】\n{ocr_text}\n")
                            print(f"添加了长度为 {len(ocr_text)} 的OCR文本")
                
                # 去除空段落
                main_content = [p for p in main_content if (isinstance(p, str) and p.strip()) or isinstance(p, dict) or isinstance(p, tuple) or isinstance(p, list)]
                print(f"清理后的段落总数: {len(main_content)}")
                
                # 清理文本并去重
                cleaned_content = self._clean_text(main_content)
                cleaned_content = self._remove_duplicates(cleaned_content)
                
                # 分离正文和附录
                main_content, appendix_content = self._split_content(cleaned_content)
                
                # 返回处理结果
                return main_content, appendix_content, tables
                    
            except Exception as e:
                print(f"处理DOCX文档时出错: {str(e)}")
                import traceback
                traceback.print_exc()
                
                # 文件损坏或格式错误时，尝试从PDF转换
                print("\n尝试将文件转换为PDF格式后再处理...")
                temp_pdf = self._convert_doc_to_pdf(file_path)
                if temp_pdf:
                    return self.process_pdf(temp_pdf)
                else:
                    raise ValueError(f"无法处理文件: {file_path}")
        
        elif file_ext == '.pdf':
            # 处理PDF文件
            return self.process_pdf(file_path)
        
        elif file_ext in ['.html', '.htm']:
            # 处理HTML文件
            print("\n处理HTML文件...")
            # 转换为DOCX
            temp_docx = self._convert_html_to_docx(file_path)
            if temp_docx:
                print(f"HTML已转换为DOCX: {temp_docx}")
                # 递归调用，处理转换后的DOCX
                return self.clean_doc(temp_docx)
            else:
                raise ValueError(f"无法处理HTML文件: {file_path}")
        
        elif file_ext in ['.xls', '.xlsx']:
            # 处理Excel文件
            print("\n处理Excel文件...")
            # 转换为DOCX
            temp_docx = self._convert_excel_to_docx(file_path)
            if temp_docx:
                print(f"Excel已转换为DOCX: {temp_docx}")
                # 递归调用，处理转换后的DOCX
                return self.clean_doc(temp_docx)
            else:
                raise ValueError(f"无法处理Excel文件: {file_path}")
        
        else:
            # 不支持的文件格式
            raise ValueError(f"不支持的文件格式: {file_ext}")

    def _clean_text(self, text: List[Any]) -> List[Any]:
        """
        清理文本内容
        
        Args:
            text: 待清理的文本段落列表
            
        Returns:
            List[Any]: 清理后的文本段落列表
        """
        cleaned = []
        for paragraph in text:
            # 如果是字典类型，说明是带有类型标记的元数据，直接添加
            if isinstance(paragraph, dict):
                cleaned.append(paragraph)
                continue
                
            # 如果是表格标记，直接保留
            if isinstance(paragraph, str) and paragraph.startswith('TABLE_PLACEHOLDER_'):
                cleaned.append(paragraph)
                continue
                
            # 确保只对字符串类型调用strip()方法
            if not isinstance(paragraph, str):
                # 非字符串类型（如元组、列表等）直接保留
                cleaned.append(paragraph)
                continue
                
            # 跳过空段落
            if not paragraph.strip():
                continue
            
            # 检查是否是目录项（包含数字序号的行）
            is_toc_item = bool(re.match(r'^\s*(?:\d+\.)*\d+\s+.*', paragraph))
            
            if not is_toc_item:
                # 移除页眉页脚
                for pattern in self.header_footer_patterns:
                    paragraph = re.sub(pattern, '', paragraph, flags=re.IGNORECASE)
                
                # 移除特殊符号
                for pattern in self.special_char_patterns:
                    paragraph = re.sub(pattern, '', paragraph, flags=re.IGNORECASE)
            
            # 如果段落不为空，添加到结果中
            if paragraph.strip():
                cleaned.append(paragraph.strip())
        
        return cleaned

    def _split_content(self, paragraphs: List[Any]) -> Tuple[List[Any], List[Any]]:
        """
        分离正文与附录/参考文献
        
        Args:
            paragraphs: 文档段落列表
            
        Returns:
            Tuple[List[Any], List[Any]]: (正文段落列表, 附录段落列表)
        """
        main_content = []
        appendix = []
        is_appendix = False
        
        for p in paragraphs:
            # 对于字典类型（元数据），直接处理
            if isinstance(p, dict):
                if not is_appendix:
                    main_content.append(p)
                else:
                    appendix.append(p)
                continue
                
            # 检查是否是附录开始
            if isinstance(p, str) and any(re.match(pattern, p, re.IGNORECASE) for pattern in self.appendix_patterns):
                is_appendix = True
            
            if is_appendix:
                appendix.append(p)
            else:
                main_content.append(p)
        
        return main_content, appendix

    def _get_embeddings(self, texts: List[str]) -> np.ndarray:
        """
        使用Ollama获取文本嵌入向量
        
        Args:
            texts: 文本列表
            
        Returns:
            np.ndarray: 嵌入向量矩阵
        """
        embeddings = []
        
        for text in texts:
            try:
                response = requests.post(
                    f"{self.ollama_host}/api/embeddings",
                    json={
                        "model": self.embedding_model,
                        "prompt": text
                    }
                )
                response.raise_for_status()
                embedding = response.json()["embedding"]
                embeddings.append(embedding)
            except Exception as e:
                print(f"获取文本嵌入失败: {str(e)}")
                # 如果获取嵌入失败，使用零向量
                embeddings.append([0.0] * 768)  # nomic-embed-text 模型输出维度为768
                
        return np.array(embeddings)

    def _remove_duplicates(self, paragraphs: List[Any], similarity_threshold: float = 0.92) -> List[Any]:
        """
        删除重复段落，保持表格占位符的位置不变
        
        Args:
            paragraphs: 段落列表
            similarity_threshold: 相似度阈值，使用嵌入模型后可以设置更高的阈值
            
        Returns:
            List[Any]: 去重后的段落列表
        """
        if not paragraphs:
            return []
        
        # 分离表格占位符和普通段落
        table_placeholders = {}
        text_paragraphs = []
        for i, p in enumerate(paragraphs):
            # 处理字典类型（元数据）
            if isinstance(p, dict):
                table_placeholders[i] = p
                continue
                
            # 处理字符串类型
            if isinstance(p, str) and p.startswith('TABLE_PLACEHOLDER_'):
                table_placeholders[i] = p
            elif isinstance(p, str):
                text_paragraphs.append((i, p))
            else:
                # 处理其他类型（如元组、列表等）
                table_placeholders[i] = p
                
        try:
            # 只对非表格段落进行去重
            if text_paragraphs:
                # 获取文本嵌入
                text_only = [p[1] for p in text_paragraphs]
                embeddings = self._get_embeddings(text_only)
                
                # 计算余弦相似度矩阵
                similarity_matrix = cosine_similarity(embeddings)
                
                # 标记要保留的段落
                keep_indices = []
                for i in range(len(text_paragraphs)):
                    # 如果当前段落没有与之前的段落高度相似，则保留
                    if not any(similarity_matrix[i][j] > similarity_threshold for j in keep_indices):
                        keep_indices.append(i)
                
                # 保留的非表格段落
                kept_paragraphs = [(text_paragraphs[i][0], text_only[i]) for i in keep_indices]
            else:
                kept_paragraphs = []
            
            # 合并表格占位符和保留的段落，按原始位置排序
            all_kept = list(table_placeholders.items()) + kept_paragraphs
            all_kept.sort(key=lambda x: x[0])
            
            return [p[1] for p in all_kept]
            
        except Exception as e:
            print(f"使用Ollama嵌入模型失败，回退到TF-IDF方法: {str(e)}")
            # 如果使用Ollama失败，回退到原来的TF-IDF方法
            return self._remove_duplicates_tfidf(paragraphs)
    
    def _remove_duplicates_tfidf(self, paragraphs: List[Any], similarity_threshold: float = 0.85) -> List[Any]:
        """
        使用TF-IDF方法删除重复段落（作为备选方案）
        
        Args:
            paragraphs: 段落列表
            similarity_threshold: 相似度阈值
            
        Returns:
            List[Any]: 去重后的段落列表
        """
        if not paragraphs:
            return []
            
        # 分离表格占位符和普通段落
        table_placeholders = {}
        text_paragraphs = []
        for i, p in enumerate(paragraphs):
            # 处理字典类型（元数据）
            if isinstance(p, dict):
                table_placeholders[i] = p
                continue
                
            # 处理字符串类型
            if isinstance(p, str) and p.startswith('TABLE_PLACEHOLDER_'):
                table_placeholders[i] = p
            elif isinstance(p, str):
                text_paragraphs.append((i, p))
            else:
                # 处理其他类型（如元组、列表等）
                table_placeholders[i] = p
        
        if text_paragraphs:
            # 计算TF-IDF矩阵
            text_only = [p[1] for p in text_paragraphs]
            tfidf_matrix = self.vectorizer.fit_transform(text_only)
            
            # 计算余弦相似度矩阵
            similarity_matrix = cosine_similarity(tfidf_matrix)
            
            # 标记要保留的段落
            keep_indices = []
            for i in range(len(text_paragraphs)):
                # 如果当前段落没有与之前的段落高度相似，则保留
                if not any(similarity_matrix[i][j] > similarity_threshold for j in keep_indices):
                    keep_indices.append(i)
            
            # 保留的非表格段落
            kept_paragraphs = [(text_paragraphs[i][0], text_only[i]) for i in keep_indices]
        else:
            kept_paragraphs = []
        
        # 合并表格占位符和保留的段落，按原始位置排序
        all_kept = list(table_placeholders.items()) + kept_paragraphs
        all_kept.sort(key=lambda x: x[0])
        
        return [p[1] for p in all_kept]

    def save_as_docx(self, cleaned_content: List[str], appendix: List[str], tables: List[Table], output_path: str):
        """
        将清理后的内容保存为docx格式、txt格式和markdown格式
        
        Args:
            cleaned_content: 清理后的正文段落列表
            appendix: 附录段落列表
            tables: 表格列表
            output_path: 输出文件路径
        """
        print(f"\n开始保存文档: {output_path}")
        print(f"- 正文元素数: {len(cleaned_content)}")
        print(f"- 附录元素数: {len(appendix)}")
        print(f"- 表格总数: {len(tables)}")
        
        # 创建新文档
        doc = docx.Document()
        
        # 创建文本输出内容列表
        text_output = []
        # 创建Markdown输出内容列表
        markdown_output = []
        
        # 添加正文内容和表格，保持它们的相对位置
        print("\n处理正文内容...")
        
        # 创建一个列表来存储所有要插入的元素
        elements_to_insert = []
        
        # 在Markdown文件中添加标题
        #markdown_output.append("# 文档内容\n")
        
        # 标记是否要跳过元数据内容在Markdown输出
        skip_metadata_in_markdown = True
        
        for i, content in enumerate(cleaned_content):
            try:
                # 处理带类型标记的元数据
                if isinstance(content, dict):
                    content_type = content.get("type", "")
                    content_value = content.get("content", "")
                    
                    # 添加到文本输出
                    if content_type in ["metadata_header", "metadata", "metadata_separator"]:
                        text_output.append(content_value)
                        
                        # 对于Word文档，添加元数据内容
                        if content_type == "metadata_header":
                            p = doc.add_paragraph(content_value)
                            p.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
                            elements_to_insert.append(('paragraph', p._element))
                        elif content_type == "metadata":
                            p = doc.add_paragraph(content_value)
                            p.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
                            elements_to_insert.append(('paragraph', p._element))
                        
                        # 不将元数据添加到Markdown输出
                        if skip_metadata_in_markdown:
                            continue
                    
                    continue
                
                # 确保content是字符串类型
                if not isinstance(content, str):
                    print(f"跳过非字符串内容: {type(content)}")
                    continue
                
                # 检查是否是表格占位符
                table_match = re.match(r'TABLE_PLACEHOLDER_(\d+)', content)
                if table_match:
                    table_index = int(table_match.group(1))
                    print(f"正在处理表格占位符: {content} (索引: {table_index})")
                    if table_index < len(tables):
                        table = tables[table_index]
                        try:
                            # 转换表格为文本格式
                            table_text = self.table_processor.convert_to_markdown(table)
                            
                            # 添加表格标题
                            title = doc.add_paragraph()
                            title.add_run("表格 " + str(table_index + 1))
                            title.style = 'Heading 2'
                            
                            # 添加表格文本
                            text_output.append(f"\n表格 {table_index + 1}:")
                            text_output.append(table_text)
                            text_output.append("")  # 添加空行
                            
                            # 添加到Markdown输出
                            markdown_output.append(table_text)
                            markdown_output.append("")  # 在表格后添加空行
                            
                        except Exception as e:
                            print(f"处理表格 {table_index + 1} 失败: {str(e)}")
                            elements_to_insert.append(('paragraph', doc.add_paragraph("【表格处理失败】")._element))
                            text_output.append("【表格处理失败】")
                            markdown_output.append("【表格处理失败】")
                else:
                    # 添加普通段落
                    p = doc.add_paragraph(content)
                    p.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
                    elements_to_insert.append(('paragraph', p._element))
                    # 添加到文本输出
                    text_output.append(content)
                    
                    # 检查段落层级，可能是标题
                    if re.match(r'^第[一二三四五六七八九十]+章', content) or re.match(r'^[1-9]\.\s+', content):
                        # 可能是章节标题
                        markdown_output.append(f"\n## {content}")
                    elif re.match(r'^[1-9]\.[1-9]\s+', content) or re.match(r'^（[一二三四五六七八九十]+）', content):
                        # 可能是二级标题
                        markdown_output.append(f"\n### {content}")
                    else:
                        # 普通段落
                        markdown_output.append(content)
            except Exception as e:
                print(f"警告：处理段落或表格时出错: {str(e)}")
                continue
        
        # 按顺序将所有元素插入文档
        for element_type, element in elements_to_insert:
            doc._body._element.append(element)
        
        # 如果有附录，添加分隔符和附录内容
        if appendix:
            print("\n处理附录内容...")
            try:
                # 添加分页符
                doc.add_page_break()
                
                # 添加附录标题
                title = doc.add_paragraph("附录")
                title.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
                
                # 添加到文本输出
                text_output.append("附录")
                # 添加到Markdown输出
                markdown_output.append("\n## 附录")
                
                # 添加附录内容
                appendix_elements = []
                for content in appendix:
                    # 确保content是字符串类型
                    if not isinstance(content, str):
                        print(f"跳过非字符串附录内容: {type(content)}")
                        continue
                        
                    # 检查是否是表格占位符
                    table_match = re.match(r'TABLE_PLACEHOLDER_(\d+)', content)
                    if table_match:
                        table_index = int(table_match.group(1))
                        print(f"正在处理附录中的表格占位符: {content} (索引: {table_index})")
                        if table_index < len(tables):
                            table = tables[table_index]
                            try:
                                # 转换表格为文本格式
                                table_text = self.table_processor.convert_to_markdown(table)
                                
                                # 添加表格标题
                                title = doc.add_paragraph()
                                title.add_run("表格 " + str(table_index + 1))
                                title.style = 'Heading 2'
                                
                                # 添加表格文本
                                text_output.append(f"\n表格 {table_index + 1}:")
                                text_output.append(table_text)
                                text_output.append("")  # 添加空行
                                
                                # 添加到Markdown输出
                                markdown_output.append(table_text)
                                markdown_output.append("")  # 在表格后添加空行
                                
                            except Exception as e:
                                print(f"处理表格 {table_index + 1} 失败: {str(e)}")
                                elements_to_insert.append(('paragraph', doc.add_paragraph("【表格处理失败】")._element))
                                text_output.append("【表格处理失败】")
                                markdown_output.append("【表格处理失败】")
                    else:
                        p = doc.add_paragraph(content)
                        p.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
                        appendix_elements.append(('paragraph', p._element))
                        # 添加到文本输出
                        text_output.append(content)
                        # A添加到Markdown输出
                        markdown_output.append(content)
                
                # 按顺序将附录元素插入文档
                for element_type, element in appendix_elements:
                    doc._body._element.append(element)
                    
            except Exception as e:
                print(f"警告：处理附录时出错: {str(e)}")
                
        # 保存docx文档
        try:
            doc.save(output_path)
            print("\nWord文档保存成功!")
        except Exception as e:
            print(f"错误：保存Word文档时出错: {str(e)}")
            raise
            
        # 保存文本文件
        try:
            text_file_path = os.path.splitext(output_path)[0] + '.txt'
            text_output = []
            
            # 处理正文内容
            for content in cleaned_content:
                if isinstance(content, str):
                    if content.startswith('TABLE_PLACEHOLDER_'):
                        # 处理表格
                        table_match = re.match(r'TABLE_PLACEHOLDER_(\d+)', content)
                        if table_match:
                            table_index = int(table_match.group(1))
                            if table_index < len(tables):
                                table = tables[table_index]
                                # 将表格转换为文本
                                table_text = self.table_processor._convert_table_to_text(table)
                                if table_text:
                                    text_output.append(table_text)
                    else:
                        text_output.append(content)
            
            # 处理附录内容
            if appendix:
                text_output.append("附录")
                for content in appendix:
                    if isinstance(content, str):
                        if content.startswith('TABLE_PLACEHOLDER_'):
                            # 处理表格
                            table_match = re.match(r'TABLE_PLACEHOLDER_(\d+)', content)
                            if table_match:
                                table_index = int(table_match.group(1))
                                if table_index < len(tables):
                                    table = tables[table_index]
                                    # 将表格转换为文本
                                    table_text = self.table_processor._convert_table_to_text(table)
                                    if table_text:
                                        text_output.append(table_text)
                        else:
                            text_output.append(content)
            
            # 处理文本内容
            processed_items = []
            for t in text_output:
                try:
                    if isinstance(t, str):
                        if t.strip():  # 只处理非空字符串
                            processed_items.append(t.replace('\n', ' ').strip())
                    elif isinstance(t, dict) and 'content' in t:
                        # 如果是元数据字典，提取其内容
                        content = t.get('content', '')
                        if isinstance(content, str) and content.strip():
                            processed_items.append(content.replace('\n', ' ').strip())
                except Exception as item_err:
                    print(f"处理文本项时出错: {str(item_err)}")
                    continue
            
            # 合并所有文本
            text_content = ' '.join(processed_items)
            
            # 保存文本文件
            with open(text_file_path, 'w', encoding='utf-8') as f:
                f.write(text_content)
            print(f"文本文件保存成功: {text_file_path}")
            
        except Exception as e:
            print(f"错误：保存文本文件时出错: {str(e)}")
            raise
            
        # 保存Markdown文件
        try:
            markdown_file_path = os.path.splitext(output_path)[0] + '.md'
            
            # 处理markdown输出项，确保所有项都是字符串
            sanitized_markdown = []
            for item in markdown_output:
                if isinstance(item, str):
                    sanitized_markdown.append(item)
                else:
                    print(f"跳过非字符串Markdown项: {type(item)}")
            
            markdown_content = '\n\n'.join(sanitized_markdown)  # 使用两个换行符分隔段落
            with open(markdown_file_path, 'w', encoding='utf-8') as f:
                f.write(markdown_content)
            print(f"Markdown文件保存成功: {markdown_file_path}")
        except Exception as e:
            print(f"错误：保存Markdown文件时出错: {str(e)}")
            raise

    def _convert_doc_to_pdf(self, doc_path: str) -> str:
        """
        将DOC/DOCX文件转换为PDF格式
        
        Args:
            doc_path: DOC/DOCX文件路径
            
        Returns:
            str: 转换后的PDF文件路径，失败时返回None
        """
        print(f"\n开始将文档转换为PDF: {doc_path}")
        
        # 创建临时目录
        temp_dir = tempfile.mkdtemp()
        pdf_path = os.path.join(temp_dir, os.path.splitext(os.path.basename(doc_path))[0] + '.pdf')
        
        try:
            # 使用 LibreOffice 转换
            if os.name == 'nt':  # Windows
                soffice_path = r"C:\Program Files\LibreOffice\program\soffice.exe"
                if not os.path.exists(soffice_path):
                    soffice_path = r"C:\Program Files (x86)\LibreOffice\program\soffice.exe"
                if not os.path.exists(soffice_path):
                    raise FileNotFoundError("找不到 LibreOffice，请确保已安装")
                
                cmd = [
                    soffice_path,
                    '--headless',
                    '--convert-to',
                    'pdf',
                    '--outdir',
                    temp_dir,
                    doc_path
                ]
            else:  # Linux/Unix
                cmd = [
                    'soffice',
                    '--headless',
                    '--convert-to',
                    'pdf',
                    '--outdir',
                    temp_dir,
                    doc_path
                ]
            
            # 执行转换命令
            print(f"执行转换命令: {' '.join(cmd)}")
            result = subprocess.run(cmd, capture_output=True, text=True)
            
            if result.returncode != 0:
                raise Exception(f"转换失败: {result.stderr}")
            
            # 验证转换结果
            if not os.path.exists(pdf_path):
                raise FileNotFoundError(f"转换后的文件不存在: {pdf_path}")
                
            print(f"文档转换为PDF完成: {pdf_path}")
            return pdf_path
            
        except Exception as e:
            print(f"文档转换为PDF失败: {str(e)}")
            # 清理临时目录
            if os.path.exists(temp_dir):
                try:
                    shutil.rmtree(temp_dir)
                except Exception as clean_err:
                    print(f"清理临时目录失败: {str(clean_err)}")
            
            return None

    def _extract_table_row(self, row_element, namespace):
        """
        提取表格行数据，增强的表格行处理
        
        Args:
            row_element: 行元素
            namespace: XML命名空间
            
        Returns:
            List[Dict]: 行数据列表
        """
        cells = []
        try:
            # 处理单元格
            for cell_element in row_element.findall('.//w:tc', namespaces=namespace):
                try:
                    cell_text = ''
                    # 提取单元格中的所有文本
                    for paragraph in cell_element.findall('.//w:p', namespaces=namespace):
                        for run in paragraph.findall('.//w:t', namespaces=namespace):
                            if run.text:
                                cell_text += run.text
                        # 在段落后添加换行符
                        cell_text += '\n'
                    
                    # 移除末尾换行
                    cell_text = cell_text.rstrip('\n')
                    
                    # 检查单元格合并属性
                    gridspan = 1
                    vmerge = None
                    
                    # 获取gridspan值
                    gridspan_elem = cell_element.find('.//w:gridSpan', namespaces=namespace)
                    if gridspan_elem is not None:
                        try:
                            gridspan = int(gridspan_elem.get(self.qn('w:val'), 1))
                        except (ValueError, TypeError):
                            print(f"警告：无效的gridspan值")
                            gridspan = 1
                    
                    # 获取vmerge值
                    vmerge_elem = cell_element.find('.//w:vMerge', namespaces=namespace)
                    if vmerge_elem is not None:
                        vmerge = vmerge_elem.get(self.qn('w:val'), 'continue')
                    
                    # 创建单元格数据
                    cell = {
                        'text': cell_text.strip(),
                        'gridspan': max(1, gridspan),  # 确保至少为1
                        'vmerge': vmerge
                    }
                    cells.append(cell)
                    
                except Exception as cell_err:
                    print(f"处理单元格时出错: {str(cell_err)}")
                    # 添加空单元格作为替代
                    cells.append({
                        'text': '',
                        'gridspan': 1,
                        'vmerge': None
                    })
            
            # 如果行为空，创建至少一个空单元格
            if not cells:
                cells.append({
                    'text': '',
                    'gridspan': 1,
                    'vmerge': None
                })
                
            return cells
            
        except Exception as e:
            print(f"提取表格行数据时出错: {str(e)}")
            # 返回至少有一个单元格的行
            return [{
                'text': '',
                'gridspan': 1,
                'vmerge': None
            }]

    def _preprocess_table(self, element, namespace):
        """
        预处理表格元素，提取表格数据
        
        Args:
            element: 表格元素
            namespace: XML命名空间
            
        Returns:
            TableData: 处理后的表格数据
        """
        try:
            # 创建新的TableData对象
            table_data = TableData()
            
            # 获取表格样式
            style_elem = element.find('.//{%s}tblStyle' % namespace['w'])
            if style_elem is not None:
                table_data.style = style_elem.get(self.qn('w:val'))
            
            # 获取表格网格信息
            grid_cols = element.findall('.//{%s}gridCol' % namespace['w'])
            table_data.columns = [{'width': col.get(self.qn('w:w'))} for col in grid_cols]
            
            # 处理表格行
            rows = element.findall('.//{%s}tr' % namespace['w'])
            if not rows:
                print("警告：未找到表格行")
                return table_data
                
            # 分析表头结构
            header_row_count = 0
            has_multi_level_header = False
            
            # 分析前三行（如果存在）来检测表头结构
            for i, row in enumerate(rows[:min(3, len(rows))]):
                try:
                    cells = self._extract_table_row(row, namespace)
                    if not cells:  # 如果提取失败，跳过这一行
                        continue
                        
                    # 检查是否有垂直合并的单元格
                    if any(cell.get('vmerge') == 'restart' for cell in cells):
                        has_multi_level_header = True
                        header_row_count = max(header_row_count, i + 2)
                        
                    # 检查是否有水平合并的单元格
                    if any(cell.get('gridspan', 1) > 1 for cell in cells):
                        has_multi_level_header = True
                        header_row_count = max(header_row_count, i + 1)
                        
                    # 检查单元格内容是否符合表头特征
                    if any(self._is_header_cell(cell.get('text', '')) for cell in cells):
                        header_row_count = max(header_row_count, i + 1)
                except Exception as e:
                    print(f"分析表头第 {i+1} 行时出错: {str(e)}")
                    continue
            
            # 如果没有检测到多级表头，默认第一行为表头
            if not has_multi_level_header:
                header_row_count = 1
            
            table_data.has_multi_level_header = has_multi_level_header
            table_data.header_rows = header_row_count
            
            # 处理所有行
            for row in rows:
                try:
                    cells = self._extract_table_row(row, namespace)
                    if cells:  # 只添加成功提取的行
                        table_data.add_row(cells)
                except Exception as e:
                    print(f"处理表格行时出错: {str(e)}")
                    continue
            
            # 检查是否是矩阵类型表格
            if len(table_data.rows) > 0:
                # 矩阵特征：多行表头，数据单元格多为数字
                if table_data.has_multi_level_header and table_data.header_rows >= 2:
                    # 检查数据区域的单元格是否主要是数字
                    number_cells = 0
                    total_cells = 0
                    for row in table_data.rows[table_data.header_rows:]:
                        for cell in row:
                            if cell['text'].strip():
                                total_cells += 1
                                if self._is_numeric_cell(cell['text']):
                                    number_cells += 1
                    
                    if total_cells > 0 and (number_cells / total_cells) > 0.5:
                        table_data.table_type = 'matrix'
                        print(f"检测到矩阵类型表格，数字单元格比例: {number_cells/total_cells:.2f}")
            
            return table_data
            
        except Exception as e:
            print(f"预处理表格时出错: {str(e)}")
            return TableData()

    def _is_header_cell(self, text: str) -> bool:
        """
        判断单元格是否是表头
        
        Args:
            text: 单元格文本
            
        Returns:
            bool: 是否是表头
        """
        if not text:
            return False
            
        # 表头特征
        header_patterns = [
            r'^[一二三四五六七八九十]+[、\.]',  # 中文序号
            r'^\d+[\.\、]',  # 数字序号
            r'^[A-Z][\.\、]',  # 字母序号
            r'^[\(（][一二三四五六七八九十\d]+[\)）]',  # 带括号的序号
            r'^[总计合计小计]$',  # 汇总行
            r'^[项目类别分类]$'  # 常见表头词
        ]
        
        return any(re.match(pattern, text.strip()) for pattern in header_patterns)

    def _is_numeric_cell(self, text: str) -> bool:
        """
        判断单元格是否是数字
        
        Args:
            text: 单元格文本
            
        Returns:
            bool: 是否是数字
        """
        # 移除空白字符
        text = text.strip()
        if not text:
            return False
            
        # 数字模式（包括负数、小数、百分比、科学计数法）
        number_patterns = [
            r'^-?\d+\.?\d*$',  # 普通数字
            r'^-?\d+\.?\d*%$',  # 百分比
            r'^-?\d+\.?\d*[eE][+-]?\d+$',  # 科学计数法
            r'^\(?\d+\.?\d*\)?$'  # 带括号的数字（负数）
        ]
        
        return any(re.match(pattern, text) for pattern in number_patterns)

    def _extract_images_from_pdf(self, pdf_path: str, output_dir: str = None) -> List[Dict]:
        """
        直接从PDF文件中提取图片（不经过DOCX转换）
        
        Args:
            pdf_path: PDF文件路径
            output_dir: 输出目录
            
        Returns:
            List[Dict]: 提取的图片信息列表
        """
        print(f"\n开始直接从PDF提取图片: {pdf_path}")
        
        if not output_dir:
            output_dir = os.path.join(os.path.dirname(pdf_path), "pdf_images_" + str(uuid.uuid4())[:8])
        
        # 确保输出目录存在
        os.makedirs(output_dir, exist_ok=True)
        print(f"PDF图片提取输出目录: {output_dir}")
        
        image_info_list = []
        
        try:
            # 使用pdf_processor中的方法提取图片
            _, extracted_images = self.pdf_processor.process_pdf_with_ocr(pdf_path, output_dir)
            
            if extracted_images:
                print(f"从PDF直接提取了 {len(extracted_images)} 张图片")
                image_info_list.extend(extracted_images)
            else:
                print("从PDF直接提取图片失败，未找到图片")
        except Exception as e:
            print(f"直接提取PDF图片时出错: {str(e)}")
        
        return image_info_list

    def _convert_table_to_text(self, table: TableData) -> str:
        """
        将表格转换为文本格式
        
        Args:
            table: 表格数据对象
            
        Returns:
            str: 表格的文本表示
        """
        try:
            # 验证表格对象
            if not isinstance(table, TableData) or not table.rows:
                return "【无效表格】"
            
            # 获取表格的行数
            rows = len(table.rows)
            if rows == 0:
                return "【空表格】"
            
            # 存储处理后的表格数据
            text_parts = []
            
            # 处理表头
            header_rows = table.header_rows or 1
            for i in range(min(header_rows, rows)):
                try:
                    row = table.rows[i]
                    row_texts = []
                    for cell in row:
                        if isinstance(cell, dict) and 'text' in cell:
                            cell_text = cell['text'].strip()
                            if cell_text:
                                row_texts.append(cell_text)
                    if row_texts:
                        text_parts.append(' | '.join(row_texts))
                except Exception as e:
                    print(f"处理表头行 {i+1} 时出错: {str(e)}")
                    continue
            
            # 添加分隔行
            if text_parts:
                text_parts.append('-' * 40)
            
            # 处理数据行
            for i in range(header_rows, rows):
                try:
                    row = table.rows[i]
                    row_texts = []
                    for cell in row:
                        if isinstance(cell, dict) and 'text' in cell:
                            cell_text = cell['text'].strip()
                            if cell_text:
                                row_texts.append(cell_text)
                    if row_texts:
                        text_parts.append(' | '.join(row_texts))
                except Exception as e:
                    print(f"处理数据行 {i+1} 时出错: {str(e)}")
                    continue
            
            # 用换行符连接所有行
            if text_parts:
                return "\n".join(text_parts)
            else:
                return "【表格无有效数据】"
            
        except Exception as e:
            print(f"转换表格为文本时出错: {str(e)}")
            return "【表格处理失败】"

def process_directory(input_dir: str, output_dir: str = None):
    """
    处理指定目录下的所有文档文件
    
    Args:
        input_dir: 输入目录路径
        output_dir: 输出目录路径，如果为None则使用输入目录
    """
    # 如果未指定输出目录，使用输入目录
    if output_dir is None:
        output_dir = input_dir
        
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
        
    cleaner = DocCleaner()
    
    for root, _, files in os.walk(input_dir):
        for file in files:
            if file.endswith(('.doc', '.docx', '.pdf')):
                input_path = os.path.join(root, file)
                
                try:
                    # 清理文档
                    main_content, appendix, tables = cleaner.clean_doc(input_path)
                    
                    # 创建输出文件名（统一使用docx扩展名）
                    base_name = os.path.splitext(file)[0]
                    output_path = os.path.join(output_dir, f"{base_name}_cleaned.docx")
                    
                    # 保存为docx格式
                    cleaner.save_as_docx(main_content, appendix, tables, output_path)
                    
                    # 如果是PDF文件，输出OCR结果
                    if file.endswith('.pdf'):
                        ocr_results = cleaner.get_ocr_results(input_path)
                        if ocr_results:
                            print(f"\n文档 {file} 的OCR结果:")
                            for i, info in enumerate(ocr_results):
                                if info.get('ocr_text'):
                                    ocr_text = info['ocr_text']
                                    print(f"图片 {i+1}: OCR文本长度 {len(ocr_text)} 字符")
                                    # 最多显示前100个字符
                                    if ocr_text:
                                        print(f"OCR文本预览: {ocr_text[:100]}...")
                            
                except Exception as e:
                    print(f"处理文件 {file} 时出错: {str(e)}")
                    # 添加更详细的错误信息
                    if isinstance(e, subprocess.CalledProcessError):
                        print(f"命令执行错误: {e.output}")
                    elif isinstance(e, FileNotFoundError):
                        print("请确保已安装LibreOffice并将其添加到系统PATH中")

def qn(tag: str) -> str:
    """
    将标签转换为带命名空间的格式
    
    Args:
        tag: 原始标签
        
    Returns:
        str: 带命名空间的标签
    """
    prefix = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}"
    return prefix + tag

if __name__ == '__main__':
    import argparse
    
    # 创建一个解析器
    parser = argparse.ArgumentParser(description='文档清理和PDF转换工具')
    
    # 添加参数
    parser.add_argument('--dir', help='要处理的目录路径')
    parser.add_argument('--pdf', help='要处理的PDF文件路径')
    parser.add_argument('--doc', help='要处理的DOC/DOCX文件路径')
    parser.add_argument('--image', help='要处理的图片文件路径')
    parser.add_argument('--output', help='输出目录路径')
    parser.add_argument('--convert_only', action='store_true', help='仅执行PDF到DOCX的转换，不进行清理')
    parser.add_argument('--ocr_only', action='store_true', help='仅执行OCR，不进行其他处理')
    parser.add_argument('--tesseract', help='Tesseract OCR可执行文件路径')
    parser.add_argument('--lang', default='chi_sim+eng', help='OCR语言，默认为中文简体+英文')
    parser.add_argument('--verbose', action='store_true', help='显示详细处理信息')
    
    # 解析命令行参数
    args = parser.parse_args()
    
    # 创建DocCleaner实例
    cleaner = DocCleaner(tesseract_cmd=args.tesseract)
    
    if args.image:
        # 直接处理单个图片
        try:
            image_path = os.path.normpath(args.image)
            output_dir = os.path.normpath(args.output) if args.output else os.path.dirname(image_path)
            
            print(f"\n{'='*80}")
            print(f"【开始图片OCR处理】")
            print(f"{'='*80}")
            print(f"图片路径: {image_path}")
            print(f"输出目录: {output_dir}")
            print(f"OCR语言: {args.lang}")
            if args.tesseract:
                print(f"Tesseract路径: {args.tesseract}")
            print(f"{'='*80}")
            
            # 检查文件是否存在
            if not os.path.exists(image_path):
                print(f"错误: 图片文件不存在: {image_path}")
                sys.exit(1)
                
            # 检查文件是否为图片格式
            valid_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tif', '.tiff', '.gif']
            ext = os.path.splitext(image_path)[1].lower()
            if ext not in valid_extensions:
                print(f"警告: 文件可能不是图片格式 ({ext})，但仍将尝试OCR处理")
            
            # 执行OCR处理
            start_time = time.time()
            
            # 直接使用pytesseract
            try:
                ocr_text = pytesseract.image_to_string(image_path, lang=args.lang)
                print(f"直接pytesseract识别成功")
            except Exception as e:
                print(f"直接pytesseract识别失败: {str(e)}")
                print("尝试使用pdf_processor...")
                ocr_text = cleaner.pdf_processor.ocr_single_image(image_path, output_dir)
            
            processing_time = time.time() - start_time
            
            if ocr_text:
                print(f"\n处理完成 (用时: {processing_time:.2f}秒)")
                print(f"识别到文本长度: {len(ocr_text)} 字符")
                print(f"文本预览: {ocr_text[:100]}...")
                
                # 生成OCR结果文件路径
                basename = os.path.splitext(os.path.basename(image_path))[0]
                ocr_text_file = os.path.join(output_dir, f"{basename}_ocr.txt")
                
                # 保存OCR结果
                with open(ocr_text_file, 'w', encoding='utf-8') as f:
                    f.write(ocr_text)
                    
                print(f"文本结果已保存到: {ocr_text_file}")
            else:
                print(f"\n处理完成 (用时: {processing_time:.2f}秒)")
                print(f"未识别到文本")
                
        except Exception as e:
            print(f"OCR处理失败: {str(e)}")
            import traceback
            traceback.print_exc()
    elif args.pdf:
        # 处理单个PDF文件
        pdf_path = os.path.normpath(args.pdf)
        output_dir = os.path.normpath(args.output) if args.output else os.path.dirname(pdf_path)
        
        print(f"处理PDF文件: {pdf_path}")
        print(f"输出目录: {output_dir}")
        
        if args.convert_only:
            # 仅执行PDF到DOCX的转换
            try:
                docx_path = cleaner.convert_pdf_to_doc(pdf_path, os.path.join(output_dir, os.path.splitext(os.path.basename(pdf_path))[0] + '.docx'))
                print(f"PDF转换完成: {docx_path}")
            except Exception as e:
                print(f"PDF转换失败: {str(e)}")
        elif args.ocr_only:
            # 仅执行OCR
            try:
                # 首先转换为DOCX
                docx_path = cleaner.convert_pdf_to_doc(pdf_path, os.path.join(output_dir, os.path.splitext(os.path.basename(pdf_path))[0] + '.docx'))
                # 然后提取图片并执行OCR
                images_dir = os.path.join(output_dir, os.path.splitext(os.path.basename(pdf_path))[0] + '_images')
                image_info = cleaner._extract_and_ocr_images(docx_path, images_dir)
                print(f"OCR完成，处理了 {len(image_info)} 张图片")
            except Exception as e:
                print(f"OCR处理失败: {str(e)}")
        else:
            # 执行完整处理
            try:
                main_content, appendix, tables = cleaner.process_pdf(pdf_path, output_dir)
                output_path = os.path.join(output_dir, os.path.splitext(os.path.basename(pdf_path))[0] + '_cleaned.docx')
                cleaner.save_as_docx(main_content, appendix, tables, output_path)
                print(f"PDF处理完成: {output_path}")
            except Exception as e:
                print(f"PDF处理失败: {str(e)}")
                import traceback
                traceback.print_exc()
    elif args.dir:
        # 处理整个目录
        input_dir = os.path.normpath(args.dir)
        output_dir = os.path.normpath(args.output) if args.output else input_dir
        process_directory(input_dir, output_dir)
    elif args.doc:
        # 处理单个DOC/DOCX文件
        doc_path = os.path.normpath(args.doc)
        output_dir = os.path.normpath(args.output) if args.output else os.path.dirname(doc_path)
        
        try:
            main_content, appendix, tables = cleaner.clean_doc(doc_path)
            output_path = os.path.join(output_dir, os.path.splitext(os.path.basename(doc_path))[0] + '_cleaned.docx')
            cleaner.save_as_docx(main_content, appendix, tables, output_path)
            print(f"文档处理完成: {output_path}")
        except Exception as e:
            print(f"文档处理失败: {str(e)}")
            import traceback
            traceback.print_exc()
    else:
        # 默认处理目录
        default_dir = "D:/rzData/poject/AI项目/中烟/后台服务/es数据/数据验证"
        print(f"未指定处理对象，使用默认目录: {default_dir}")
        process_directory(default_dir, default_dir)