pip install pymupdf
pip install ollama
pip install pillow

import fitz  # PyMuPDF
import os
import tempfile
from PIL import Image
import io
import ollama


class PDFTranslator:
    def __init__(self, source_pdf_path, model="qwen2.5:7b"):
        """
        初始化PDF翻譯器
        
        Args:
            source_pdf_path (str): 源PDF文件路徑
            model (str): Ollama模型名稱
        """
        self.source_pdf_path = source_pdf_path
        self.doc = fitz.open(source_pdf_path)
        self.model = model
        
    def extract_text_and_positions(self, page_num):
        """
        提取指定頁面的文本及其位置信息
        
        Args:
            page_num (int): 頁面編號（從0開始）
            
        Returns:
            list: 包含文本塊信息的列表
        """
        page = self.doc[page_num]
        text_blocks = []
        
        # 獲取頁面上的文本塊
        blocks = page.get_text("dict")["blocks"]
        
        for block in blocks:
            if "lines" in block:  # 文本塊
                for line in block["lines"]:
                    for span in line["spans"]:
                        text_blocks.append({
                            "text": span["text"],
                            "bbox": span["bbox"],  # 邊界框 [x0, y0, x1, y1]
                            "size": span["size"],
                            "font": span["font"],
                            "color": span["color"]
                        })
        
        return text_blocks
    
    def extract_images(self, page_num):
        """
        提取指定頁面的圖片
        
        Args:
            page_num (int): 頁面編號（從0開始）
            
        Returns:
            list: 包含圖片信息的列表
        """
        page = self.doc[page_num]
        image_list = []
        
        # 獲取頁面上的圖片
        image_list_raw = page.get_images()
        
        for img_index, img in enumerate(image_list_raw):
            xref = img[0]
            pix = fitz.Pixmap(self.doc, xref)
            
            # 如果是CMYK圖片，轉換為RGB
            if pix.n < 5:
                img_data = pix.tobytes("png")
            else:
                pix1 = fitz.Pixmap(fitz.csRGB, pix)
                img_data = pix1.tobytes("png")
                pix1 = None
            
            # 獲取圖片在頁面上的位置
            img_rects = page.get_image_rects(xref)
            
            image_info = {
                "image_data": img_data,
                "rect": img_rects[0] if img_rects else None,
                "xref": xref
            }
            
            image_list.append(image_info)
            pix = None
        
        return image_list
    
    def translate_text(self, text, dest_lang='zh'):
        """
        使用Ollama大模型翻譯文本
        
        Args:
            text (str): 要翻譯的文本
            dest_lang (str): 目標語言
            
        Returns:
            str: 翻譯后的文本
        """
        try:
            # 構建翻譯提示，明確要求將英文翻譯成中文，只返回翻譯結果，保持原文格式
            prompt = f"""請將以下英文文本翻譯成中文，保持原文的格式、空格和標點符號，只返回翻譯結果，不要添加任何解釋。

翻譯要求：
1. 所有代碼內(nèi)容（包括代碼塊、函數(shù)名、類名、變量名、命令、配置項等）必須保持原樣，不得翻譯。
2. 所有網(wǎng)址（以 http://、https://、www. 開頭的鏈接）必須保持原樣，不得翻譯。
3. 所有數(shù)字保持原樣，不得翻譯或改寫（包括整數(shù)、小數(shù)、百分比、版本號、時間、日期、編號等）。
4. 保持原文中的空格、換行、縮進等格式，確保翻譯后格式一致。
5. 僅翻譯自然語言描述性的英文文本，其余內(nèi)容全部保持不變。

英文文本如下：
{text}
"""
            
            print(f"正在翻譯文本: {text[:50]}..." if len(text) > 50 else f"正在翻譯文本: {text}")
            
            # 調(diào)用Ollama模型
            response = ollama.chat(
                model=self.model,
                messages=[
                    {
                        'role': 'user',
                        'content': prompt
                    }
                ]
            )
            
            translated = response['message']['content'].strip()
            print(f"翻譯結果: {translated[:50]}..." if len(translated) > 50 else f"翻譯結果: {translated}")
            
            return translated
        except Exception as e:
            print(f"翻譯錯誤: {e}")
            return text  # 如果翻譯失敗，返回原文本
    
    def create_translated_pdf(self, output_path, dest_lang='zh', start_page=0, end_page=None):
        """
        創(chuàng)建翻譯后的PDF文件，保持原有版面布局
        
        Args:
            output_path (str): 輸出PDF文件路徑
            dest_lang (str): 目標語言
            start_page (int): 開始頁面（從0開始）
            end_page (int): 結束頁面（從0開始，None表示到最后一頁）
        """
        # 確定頁面范圍
        if end_page is None:
            end_page = len(self.doc) - 1
        else:
            end_page = min(end_page, len(self.doc) - 1)
        
        # 處理指定范圍的頁面
        for page_num in range(start_page, end_page + 1):
            print(f"正在處理第 {page_num + 1} 頁...（共{len(self.doc)}頁）")
            
            # 創(chuàng)建新的PDF文檔
            new_doc = fitz.open()
            
            # 獲取原始頁面信息
            original_page = self.doc.load_page(page_num)
            page_width = original_page.rect.width
            page_height = original_page.rect.height
            
            # 創(chuàng)建新頁面
            new_page = new_doc.new_page(width=page_width, height=page_height)
            
            # 復制原始頁面的布局和圖片
            original_page = self.doc[page_num]
            
            # 復制圖片
            images = self.extract_images(page_num)
            for img_info in images:
                if img_info["rect"]:
                    # 插入原始圖片
                    new_page.insert_image(img_info["rect"], stream=img_info["image_data"])
            
            # 提取并翻譯文本
            text_blocks = self.extract_text_and_positions(page_num)
            
            # 為了更好地保持版面，我們需要更精確地處理文本
            for block in text_blocks:
                if block["text"].strip():  # 避免空文本
                    translated_text = self.translate_text(block["text"], dest_lang)
                    
                    # 計算文本位置
                    bbox = block["bbox"]
                    x0, y0, x1, y1 = bbox
                    
                    # 創(chuàng)建文本插入點（使用左下角作為基點）
                    # fitz使用笛卡爾坐標系，y軸向上
                    point = fitz.Point(x0, y0 + block["size"])
                    
                    # 使用text writer來保持更好的版面
                    # 首先擦除原始文本區(qū)域（可選）
                    # 然后插入翻譯后的文本
                    # 檢查文本是否包含中文字符，如果是，則使用中文字體
                    if any(ord(char) > 127 for char in translated_text):  # 包含非ASCII字符（如中文）
                        try:
                            new_page.insert_text(
                                point,
                                translated_text,
                                fontsize=block["size"],
                                fontname="china-ss",
                                color=(0, 0, 0)  # 強制使用黑色文字以確?？梢?
                            )
                        except:
                            # 如果內(nèi)置字體失敗，使用默認字體
                            new_page.insert_text(
                                point,
                                translated_text,
                                fontsize=block["size"],
                                color=(0, 0, 0)  # 強制使用黑色文字以確?？梢?
                            )
                    else:
                        # 如果是英文文本，使用原始字體
                        try:
                            new_page.insert_text(
                                point,
                                translated_text,
                                fontsize=block["size"],
                                fontname=block["font"],
                                color=(0, 0, 0)  # 強制使用黑色文字以確?？梢?
                            )
                        except:
                            new_page.insert_text(
                                point,
                                translated_text,
                                fontsize=block["size"],
                                color=(0, 0, 0)  # 強制使用黑色文字以確?？梢?
                            )
                else:
                    # 如果是空文本，直接復制原始文本（如空格等）
                    bbox = block["bbox"]
                    x0, y0, x1, y1 = bbox
                    point = fitz.Point(x0, y0 + block["size"])
                    
                    # 對于空文本塊，也檢查是否包含中文字符
                    if any(ord(char) > 127 for char in block["text"]):  # 包含非ASCII字符（如中文）
                        try:
                            new_page.insert_text(
                                point,
                                block["text"],
                                fontsize=block["size"],
                                fontname="china-ss",
                                color=(0, 0, 0)  # 強制使用黑色文字以確?？梢?
                            )
                        except:
                            # 如果內(nèi)置字體失敗，使用默認字體
                            new_page.insert_text(
                                point,
                                block["text"],
                                fontsize=block["size"],
                                color=(0, 0, 0)  # 強制使用黑色文字以確保可見
                            )
                    else:
                        # 如果是英文文本，使用原始字體
                        try:
                            new_page.insert_text(
                                point,
                                block["text"],
                                fontsize=block["size"],
                                fontname=block["font"],
                                color=(0, 0, 0)  # 強制使用黑色文字以確?？梢?
                            )
                        except:
                            new_page.insert_text(
                                point,
                                block["text"],
                                fontsize=block["size"],
                                color=(0, 0, 0)  # 強制使用黑色文字以確?？梢?
                            )
            
            # 為每一頁創(chuàng)建單獨的PDF文件
            page_output_path = output_path.replace('.pdf', f'_page_{page_num + 1}.pdf')
            new_doc.save(page_output_path)
            new_doc.close()
            print(f"第 {page_num + 1} 頁翻譯完成，輸出文件: {page_output_path}")
        
        print(f"所有頁面翻譯完成！")
    
    def get_page_count(self):
        """
        獲取PDF總頁數(shù)
        
        Returns:
            int: PDF總頁數(shù)
        """
        return len(self.doc)
    
    def close(self):
        """
        關閉文檔
        """
        if self.doc:
            self.doc.close()


def main():
    # 使用示例
    source_pdf = "1.pdf"
    output_pdf = "translated_1.pdf"
    
    # 創(chuàng)建翻譯器實例，使用Ollama模型
    translator = PDFTranslator(source_pdf, model="qwen2.5:7b")
    
    try:
        print(f"PDF總頁數(shù): {translator.get_page_count()}")
        
        # 翻譯PDF并保持版面（只翻譯前3頁作為示例）
        translator.create_translated_pdf(
            output_path=output_pdf, 
            dest_lang='zh',
            start_page=8,
            end_page=211  # 翻譯前3頁（0-2）
        )
    finally:
        # 關閉文檔
        translator.close()


if __name__ == "__main__":
    main()