# 使用Homebrew安裝
brew install tesseract

# 安裝語言包
brew install tesseract-lang

# 更新包列表
sudo apt update

# 安裝Tesseract OCR
sudo apt install tesseract-ocr

# 安裝中文語言包
sudo apt install tesseract-ocr-chi-sim tesseract-ocr-chi-tra

# 安裝Pillow用于圖像處理
pip install Pillow

# 安裝pytesseract用于調(diào)用Tesseract OCR
pip install pytesseract

# 安裝OpenCV用于高級圖像處理（可選）
pip install opencv-python

# 安裝numpy（通常OpenCV會依賴）
pip install numpy

tesseract --version

import pytesseract
from PIL import Image
import os

def basic_ocr(image_path, language='eng'):
    """
    基礎(chǔ)OCR函數(shù)：識別圖片中的文字
    
    參數(shù):
        image_path (str): 圖片文件路徑
        language (str): 識別語言，默認為英語('eng')
    
    返回:
        str: 識別出的文本內(nèi)容
    """
    try:
        # 檢查圖片文件是否存在
        if not os.path.exists(image_path):
            raise FileNotFoundError(f"圖片文件不存在: {image_path}")
        
        # 使用PIL打開圖片
        image = Image.open(image_path)
        
        # 使用Tesseract進行OCR識別
        text = pytesseract.image_to_string(image, lang=language)
        
        return text
    
    except Exception as e:
        print(f"OCR識別過程中出現(xiàn)錯誤: {str(e)}")
        return ""

# 使用示例
if __name__ == "__main__":
    # 替換為你的圖片路徑
    image_path = "sample_text.png"
    result = basic_ocr(image_path)
    print("識別結(jié)果:")
    print(result)

def multi_language_ocr(image_path, languages):
    """
    多語言OCR識別
    
    參數(shù):
        image_path (str): 圖片文件路徑
        languages (list): 語言列表，如['eng', 'chi_sim']
    
    返回:
        dict: 各語言的識別結(jié)果
    """
    results = {}
    
    for lang in languages:
        try:
            image = Image.open(image_path)
            text = pytesseract.image_to_string(image, lang=lang)
            results[lang] = text
        except Exception as e:
            print(f"語言 {lang} 識別失敗: {str(e)}")
            results[lang] = ""
    
    return results

# 使用示例
languages = ['eng', 'chi_sim', 'fra']  # 英語、簡體中文、法語
results = multi_language_ocr("multilingual_text.png", languages)

for lang, text in results.items():
    print(f"{lang} 識別結(jié)果:")
    print(text)
    print("-" * 50)

import cv2
import numpy as np
from PIL import Image

def preprocess_image(image_path, output_path=None):
    """
    圖像預處理：灰度化、二值化、去噪
    
    參數(shù):
        image_path (str): 輸入圖片路徑
        output_path (str): 預處理后圖片保存路徑（可選）
    
    返回:
        numpy.ndarray: 預處理后的圖像數(shù)組
    """
    # 讀取圖像
    image = cv2.imread(image_path)
    
    # 轉(zhuǎn)換為灰度圖
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # 使用高斯模糊去噪
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 使用Otsu's二值化方法
    _, binary = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    
    # 可選：保存預處理后的圖像
    if output_path:
        cv2.imwrite(output_path, binary)
    
    return binary

# 使用預處理后的圖像進行OCR
def ocr_with_preprocessing(image_path):
    """
    使用預處理后的圖像進行OCR識別
    
    參數(shù):
        image_path (str): 圖片路徑
    
    返回:
        str: 識別結(jié)果
    """
    # 圖像預處理
    processed_image = preprocess_image(image_path)
    
    # 將numpy數(shù)組轉(zhuǎn)換為PIL圖像
    pil_image = Image.fromarray(processed_image)
    
    # OCR識別
    text = pytesseract.image_to_string(pil_image, lang='eng')
    
    return text

def remove_noise(image):
    """
    使用形態(tài)學操作去除噪聲
    
    參數(shù):
        image (numpy.ndarray): 輸入圖像
    
    返回:
        numpy.ndarray: 去噪后的圖像
    """
    # 定義核（結(jié)構(gòu)元素）
    kernel = np.ones((1, 1), np.uint8)
    
    # 開運算：先腐蝕后膨脹，去除小噪聲點
    image = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel)
    
    # 閉運算：先膨脹后腐蝕，填充小洞
    image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
    
    return image

def correct_skew(image):
    """
    檢測并校正圖像傾斜
    
    參數(shù):
        image (numpy.ndarray): 輸入圖像
    
    返回:
        numpy.ndarray: 校正后的圖像
        float: 傾斜角度
    """
    # 邊緣檢測
    edges = cv2.Canny(image, 50, 150, apertureSize=3)
    
    # 霍夫直線檢測
    lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=100)
    
    if lines is not None:
        angles = []
        for rho, theta in lines[:, 0]:
            angle = theta * 180 / np.pi - 90
            angles.append(angle)
        
        # 計算平均角度
        median_angle = np.median(angles)
        
        # 旋轉(zhuǎn)圖像校正傾斜
        (h, w) = image.shape[:2]
        center = (w // 2, h // 2)
        M = cv2.getRotationMatrix2D(center, median_angle, 1.0)
        corrected = cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC, 
                                  borderMode=cv2.BORDER_REPLICATE)
        
        return corrected, median_angle
    
    return image, 0

def enhance_contrast(image):
    """
    增強圖像對比度
    
    參數(shù):
        image (numpy.ndarray): 輸入圖像
    
    返回:
        numpy.ndarray: 對比度增強后的圖像
    """
    # 使用CLAHE（限制對比度自適應直方圖均衡化）
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    enhanced = clahe.apply(image)
    
    return enhanced

def complete_preprocessing(image_path, output_path=None):
    """
    完整的圖像預處理流程
    
    參數(shù):
        image_path (str): 輸入圖片路徑
        output_path (str): 預處理后圖片保存路徑（可選）
    
    返回:
        numpy.ndarray: 預處理后的圖像
    """
    # 讀取圖像
    image = cv2.imread(image_path)
    
    # 轉(zhuǎn)換為灰度圖
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # 去噪
    denoised = cv2.medianBlur(gray, 3)
    
    # 對比度增強
    enhanced = enhance_contrast(denoised)
    
    # 二值化
    _, binary = cv2.threshold(enhanced, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    
    # 去除噪聲
    cleaned = remove_noise(binary)
    
    # 傾斜校正
    corrected, angle = correct_skew(cleaned)
    
    print(f"檢測到的傾斜角度: {angle:.2f}度")
    
    # 可選：保存預處理后的圖像
    if output_path:
        cv2.imwrite(output_path, corrected)
    
    return corrected

def advanced_ocr(image_path, config_options=None):
    """
    使用高級配置的OCR識別
    
    參數(shù):
        image_path (str): 圖片路徑
        config_options (str): Tesseract配置參數(shù)
    
    返回:
        dict: 包含文本和詳細信息的字典
    """
    if config_options is None:
        config_options = '--oem 3 --psm 6'
    
    image = Image.open(image_path)
    
    # 獲取識別結(jié)果和詳細信息
    data = pytesseract.image_to_data(image, config=config_options, output_type=pytesseract.Output.DICT)
    
    # 提取識別文本
    text = pytesseract.image_to_string(image, config=config_options)
    
    return {
        'text': text,
        'data': data
    }

# 常用配置參數(shù)說明
"""
--psm N: 頁面分割模式
    0 = 僅方向和腳本檢測
    1 = 自動頁面分割與文本檢測
    3 = 全自動頁面分割，無文本檢測（默認）
    6 = 統(tǒng)一文本塊
    7 = 單行文本
    8 = 單個單詞
    13 = 原始行文本

--oem N: OCR引擎模式
    0 = 僅傳統(tǒng)引擎
    1 = 僅神經(jīng)網(wǎng)絡LSTM引擎
    2 = 傳統(tǒng)+LSTM引擎
    3 = 默認，基于可用內(nèi)容選擇
"""

def get_bounding_boxes(image_path, output_image_path=None):
    """
    獲取文本邊界框并在圖像上繪制
    
    參數(shù):
        image_path (str): 輸入圖片路徑
        output_image_path (str): 帶邊界框的輸出圖片路徑（可選）
    
    返回:
        list: 邊界框信息列表
    """
    # 讀取圖像
    image = cv2.imread(image_path)
    rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    pil_image = Image.fromarray(rgb_image)
    
    # 獲取詳細的OCR數(shù)據(jù)
    data = pytesseract.image_to_data(pil_image, output_type=pytesseract.Output.DICT)
    
    boxes = []
    
    # 遍歷所有檢測到的文本元素
    n_boxes = len(data['level'])
    for i in range(n_boxes):
        # 只處理置信度較高的結(jié)果
        if int(data['conf'][i]) > 30:
            (x, y, w, h) = (data['left'][i], data['top'][i], data['width'][i], data['height'][i])
            text = data['text'][i]
            
            boxes.append({
                'text': text,
                'position': (x, y, w, h),
                'confidence': int(data['conf'][i])
            })
            
            # 在圖像上繪制邊界框
            if output_image_path:
                cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
                cv2.putText(image, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                           0.5, (0, 255, 0), 2)
    
    # 保存帶邊界框的圖像
    if output_image_path:
        cv2.imwrite(output_image_path, image)
    
    return boxes

import glob

def batch_ocr(image_folder, output_file="ocr_results.txt"):
    """
    批量處理文件夾中的圖片
    
    參數(shù):
        image_folder (str): 圖片文件夾路徑
        output_file (str): 結(jié)果輸出文件路徑
    """
    # 支持的圖片格式
    image_extensions = ['*.png', '*.jpg', '*.jpeg', '*.bmp', '*.tiff']
    
    image_paths = []
    for extension in image_extensions:
        image_paths.extend(glob.glob(os.path.join(image_folder, extension)))
    
    results = []
    
    for image_path in image_paths:
        print(f"處理圖片: {os.path.basename(image_path)}")
        
        try:
            # 預處理圖像
            processed_image = complete_preprocessing(image_path)
            pil_image = Image.fromarray(processed_image)
            
            # OCR識別
            text = pytesseract.image_to_string(pil_image, lang='eng+chi_sim')
            
            results.append({
                'file': os.path.basename(image_path),
                'text': text
            })
            
        except Exception as e:
            print(f"處理圖片 {image_path} 時出錯: {str(e)}")
            results.append({
                'file': os.path.basename(image_path),
                'text': f"識別失敗: {str(e)}"
            })
    
    # 將結(jié)果寫入文件
    with open(output_file, 'w', encoding='utf-8') as f:
        for result in results:
            f.write(f"文件: {result['file']}\n")
            f.write(f"識別結(jié)果:\n{result['text']}\n")
            f.write("=" * 50 + "\n")
    
    print(f"批量處理完成，結(jié)果已保存到: {output_file}")
    return results

def optimize_psm(image_path):
    """
    嘗試不同的頁面分割模式，找到最佳結(jié)果
    
    參數(shù):
        image_path (str): 圖片路徑
    
    返回:
        dict: 各PSM模式的識別結(jié)果
    """
    image = Image.open(image_path)
    
    # 定義不同的PSM模式及其描述
    psm_modes = {
        0: "僅方向和腳本檢測",
        1: "自動頁面分割與文本檢測",
        3: "全自動頁面分割，無文本檢測（默認）",
        6: "統(tǒng)一文本塊",
        7: "單行文本",
        8: "單個單詞",
        13: "原始行文本"
    }
    
    results = {}
    
    for psm, description in psm_modes.items():
        try:
            config = f'--psm {psm}'
            text = pytesseract.image_to_string(image, config=config)
            results[psm] = {
                'description': description,
                'text': text
            }
        except Exception as e:
            results[psm] = {
                'description': description,
                'text': f"識別失敗: {str(e)}"
            }
    
    return results

def optimize_language_model(image_path, text_type="general"):
    """
    根據(jù)文本類型優(yōu)化語言模型
    
    參數(shù):
        image_path (str): 圖片路徑
        text_type (str): 文本類型，如"general", "document", "code"等
    
    返回:
        str: 優(yōu)化后的識別結(jié)果
    """
    image = Image.open(image_path)
    
    # 根據(jù)文本類型選擇配置
    configs = {
        "general": "--oem 3 --psm 6",
        "document": "--oem 3 --psm 1",
        "single_line": "--oem 3 --psm 7",
        "single_word": "--oem 3 --psm 8",
        "code": "--oem 3 --psm 6 -c tessedit_char_whitelist=0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz{}[]();:.,<>/*-+="
    }
    
    config = configs.get(text_type, configs["general"])
    
    text = pytesseract.image_to_string(image, config=config)
    
    return text

def create_custom_dictionary(word_list, dictionary_path="custom_words.txt"):
    """
    創(chuàng)建自定義詞典
    
    參數(shù):
        word_list (list): 自定義單詞列表
        dictionary_path (str): 詞典文件保存路徑
    """
    with open(dictionary_path, 'w', encoding='utf-8') as f:
        for word in word_list:
            f.write(f"{word}\n")
    
    print(f"自定義詞典已創(chuàng)建: {dictionary_path}")

def ocr_with_custom_dictionary(image_path, dictionary_path, language='eng'):
    """
    使用自定義詞典進行OCR識別
    
    參數(shù):
        image_path (str): 圖片路徑
        dictionary_path (str): 自定義詞典路徑
        language (str): 基礎(chǔ)語言
    
    返回:
        str: 識別結(jié)果
    """
    image = Image.open(image_path)
    
    # 配置參數(shù)，加載自定義詞典
    config = f'--oem 3 --psm 6 --user-words {dictionary_path}'
    
    text = pytesseract.image_to_string(image, lang=language, config=config)
    
    return text

class DocumentOCR:
    """
    文檔OCR處理類
    """
    
    def __init__(self, language='eng+chi_sim'):
        self.language = language
    
    def process_document(self, image_path, output_text_path=None, output_pdf_path=None):
        """
        處理文檔圖片
        
        參數(shù):
            image_path (str): 文檔圖片路徑
            output_text_path (str): 文本輸出路徑（可選）
            output_pdf_path (str): PDF輸出路徑（可選）
        
        返回:
            dict: 處理結(jié)果
        """
        try:
            # 圖像預處理
            processed_image = complete_preprocessing(image_path)
            pil_image = Image.fromarray(processed_image)
            
            # 獲取文本
            text = pytesseract.image_to_string(pil_image, lang=self.language)
            
            # 獲取詳細信息用于生成搜索PDF
            pdf_data = pytesseract.image_to_pdf_or_hocr(pil_image, extension='pdf', lang=self.language)
            
            result = {
                'success': True,
                'text': text,
                'pdf_data': pdf_data
            }
            
            # 保存文本結(jié)果
            if output_text_path:
                with open(output_text_path, 'w', encoding='utf-8') as f:
                    f.write(text)
                print(f"文本結(jié)果已保存到: {output_text_path}")
            
            # 保存PDF結(jié)果
            if output_pdf_path:
                with open(output_pdf_path, 'wb') as f:
                    f.write(pdf_data)
                print(f"可搜索PDF已保存到: {output_pdf_path}")
            
            return result
            
        except Exception as e:
            print(f"文檔處理失敗: {str(e)}")
            return {
                'success': False,
                'error': str(e)
            }
    
    def batch_process_documents(self, input_folder, output_folder):
        """
        批量處理文檔文件夾
        
        參數(shù):
            input_folder (str): 輸入文件夾路徑
            output_folder (str): 輸出文件夾路徑
        """
        # 創(chuàng)建輸出文件夾
        os.makedirs(output_folder, exist_ok=True)
        
        # 獲取所有圖片文件
        image_extensions = ['*.png', '*.jpg', '*.jpeg', '*.bmp', '*.tiff']
        image_paths = []
        for extension in image_extensions:
            image_paths.extend(glob.glob(os.path.join(input_folder, extension)))
        
        results = []
        
        for image_path in image_paths:
            filename = os.path.splitext(os.path.basename(image_path))[0]
            
            output_text_path = os.path.join(output_folder, f"{filename}.txt")
            output_pdf_path = os.path.join(output_folder, f"{filename}.pdf")
            
            print(f"處理文檔: {os.path.basename(image_path)}")
            
            result = self.process_document(
                image_path, 
                output_text_path, 
                output_pdf_path
            )
            
            results.append({
                'file': os.path.basename(image_path),
                'result': result
            })
        
        return results

# 使用示例
doc_ocr = DocumentOCR(language='eng+chi_sim')
results = doc_ocr.batch_process_documents("input_docs", "output_docs")

class BusinessCardOCR:
    """
    名片OCR處理類
    """
    
    def __init__(self):
        self.contact_patterns = {
            'phone': r'(\+?[0-9]{1,3}[-.\s]?)?(\(?[0-9]{1,4}\)?[-.\s]?)?[0-9]{1,4}[-.\s]?[0-9]{1,9}',
            'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
            'website': r'((https?://)?(www\.)?[a-zA-Z0-9-]+\.[a-zA-Z]{2,}(/\S*)?)'
        }
    
    def extract_contact_info(self, image_path):
        """
        從名片圖片中提取聯(lián)系信息
        
        參數(shù):
            image_path (str): 名片圖片路徑
        
        返回:
            dict: 提取的聯(lián)系信息
        """
        import re
        
        # OCR識別
        text = basic_ocr(image_path)
        
        contact_info = {
            'raw_text': text,
            'name': '',
            'company': '',
            'phone': [],
            'email': [],
            'website': []
        }
        
        # 提取電話號碼
        phone_matches = re.findall(self.contact_patterns['phone'], text)
        contact_info['phone'] = [match[0] + match[1] for match in phone_matches if any(match)]
        
        # 提取郵箱地址
        contact_info['email'] = re.findall(self.contact_patterns['email'], text)
        
        # 提取網(wǎng)址
        website_matches = re.findall(self.contact_patterns['website'], text)
        contact_info['website'] = [match[0] for match in website_matches if match[0]]
        
        # 簡單的姓名和公司提取（實際應用中可能需要更復雜的NLP處理）
        lines = text.split('\n')
        non_empty_lines = [line.strip() for line in lines if line.strip()]
        
        if len(non_empty_lines) >= 2:
            contact_info['name'] = non_empty_lines[0]
            contact_info['company'] = non_empty_lines[1]
        
        return contact_info

# 使用示例
card_ocr = BusinessCardOCR()
contact_info = card_ocr.extract_contact_info("business_card.jpg")
print("提取的聯(lián)系信息:")
for key, value in contact_info.items():
    print(f"{key}: {value}")

def extract_table_data(image_path):
    """
    從圖片中的表格提取數(shù)據(jù)
    
    參數(shù):
        image_path (str): 包含表格的圖片路徑
    
    返回:
        list: 表格數(shù)據(jù)（二維列表）
    """
    # 預處理圖像，特別強調(diào)垂直線和水平線
    image = cv2.imread(image_path)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # 二值化
    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    
    # 檢測水平線
    horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 1))
    horizontal_lines = cv2.morphologyEx(binary, cv2.MORPH_OPEN, horizontal_kernel)
    
    # 檢測垂直線
    vertical_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 25))
    vertical_lines = cv2.morphologyEx(binary, cv2.MORPH_OPEN, vertical_kernel)
    
    # 合并線條
    table_mask = cv2.bitwise_or(horizontal_lines, vertical_lines)
    
    # OCR識別
    pil_image = Image.fromarray(cv2.bitwise_not(table_mask))
    text = pytesseract.image_to_string(pil_image)
    
    # 簡單的表格解析（實際應用可能需要更復雜的邏輯）
    table_data = []
    lines = text.split('\n')
    
    for line in lines:
        if line.strip():
            # 假設表格列由多個空格分隔
            row = [cell.strip() for cell in line.split('  ') if cell.strip()]
            if row:
                table_data.append(row)
    
    return table_data

# 使用示例
table_data = extract_table_data("table_image.png")
print("提取的表格數(shù)據(jù):")
for row in table_data:
    print(row)

import pytesseract
import cv2
import numpy as np
from PIL import Image
import os
import glob
import re

class AdvancedOCR:
    """
    高級OCR工具類
    """
    
    def __init__(self, default_language='eng'):
        self.default_language = default_language
        
    def preprocess_image(self, image_path, output_path=None):
        """
        圖像預處理
        
        參數(shù):
            image_path (str): 輸入圖片路徑
            output_path (str): 預處理后圖片保存路徑（可選）
        
        返回:
            numpy.ndarray: 預處理后的圖像
        """
        # 讀取圖像
        image = cv2.imread(image_path)
        if image is None:
            raise ValueError(f"無法讀取圖像: {image_path}")
        
        # 轉(zhuǎn)換為灰度圖
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # 去噪
        denoised = cv2.medianBlur(gray, 3)
        
        # 對比度增強
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
        enhanced = clahe.apply(denoised)
        
        # 二值化
        _, binary = cv2.threshold(enhanced, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
        
        # 形態(tài)學操作去噪
        kernel = np.ones((1, 1), np.uint8)
        cleaned = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
        cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_CLOSE, kernel)
        
        # 可選：保存預處理后的圖像
        if output_path:
            cv2.imwrite(output_path, cleaned)
        
        return cleaned
    
    def correct_skew(self, image):
        """
        校正圖像傾斜
        
        參數(shù):
            image (numpy.ndarray): 輸入圖像
        
        返回:
            numpy.ndarray: 校正后的圖像
            float: 傾斜角度
        """
        # 邊緣檢測
        edges = cv2.Canny(image, 50, 150, apertureSize=3)
        
        # 霍夫直線檢測
        lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=100)
        
        if lines is not None:
            angles = []
            for rho, theta in lines[:, 0]:
                angle = theta * 180 / np.pi - 90
                angles.append(angle)
            
            # 計算中位數(shù)角度
            median_angle = np.median(angles)
            
            # 旋轉(zhuǎn)圖像校正傾斜
            (h, w) = image.shape[:2]
            center = (w // 2, h // 2)
            M = cv2.getRotationMatrix2D(center, median_angle, 1.0)
            corrected = cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC, 
                                      borderMode=cv2.BORDER_REPLICATE)
            
            return corrected, median_angle
        
        return image, 0
    
    def extract_text(self, image_path, language=None, psm=6, preprocess=True):
        """
        提取圖像中的文本
        
        參數(shù):
            image_path (str): 圖片路徑
            language (str): 識別語言
            psm (int): 頁面分割模式
            preprocess (bool): 是否進行預處理
        
        返回:
            str: 識別出的文本
        """
        if language is None:
            language = self.default_language
        
        try:
            if preprocess:
                # 預處理圖像
                processed_image = self.preprocess_image(image_path)
                pil_image = Image.fromarray(processed_image)
            else:
                # 直接使用原圖
                pil_image = Image.open(image_path)
            
            # 配置參數(shù)
            config = f'--oem 3 --psm {psm}'
            
            # OCR識別
            text = pytesseract.image_to_string(pil_image, lang=language, config=config)
            
            return text.strip()
            
        except Exception as e:
            print(f"文本提取失敗: {str(e)}")
            return ""
    
    def extract_text_with_boxes(self, image_path, language=None, output_image_path=None, confidence_threshold=30):
        """
        提取文本及邊界框信息
        
        參數(shù):
            image_path (str): 圖片路徑
            language (str): 識別語言
            output_image_path (str): 帶邊界框的輸出圖片路徑（可選）
            confidence_threshold (int): 置信度閾值
        
        返回:
            dict: 包含文本和邊界框信息的字典
        """
        if language is None:
            language = self.default_language
        
        # 讀取圖像
        image = cv2.imread(image_path)
        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        pil_image = Image.fromarray(rgb_image)
        
        # 獲取詳細的OCR數(shù)據(jù)
        data = pytesseract.image_to_data(pil_image, lang=language, output_type=pytesseract.Output.DICT)
        
        # 提取文本和邊界框
        text_boxes = []
        n_boxes = len(data['level'])
        
        for i in range(n_boxes):
            if int(data['conf'][i]) > confidence_threshold:
                (x, y, w, h) = (data['left'][i], data['top'][i], data['width'][i], data['height'][i])
                text = data['text'][i].strip()
                
                if text:  # 只保留非空文本
                    text_boxes.append({
                        'text': text,
                        'position': (x, y, w, h),
                        'confidence': int(data['conf'][i])
                    })
                    
                    # 在圖像上繪制邊界框
                    if output_image_path:
                        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
                        cv2.putText(image, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                                   0.5, (0, 255, 0), 2)
        
        # 保存帶邊界框的圖像
        if output_image_path:
            cv2.imwrite(output_image_path, image)
        
        # 提取完整文本
        full_text = pytesseract.image_to_string(pil_image, lang=language)
        
        return {
            'full_text': full_text.strip(),
            'text_boxes': text_boxes,
            'raw_data': data
        }
    
    def batch_process(self, input_folder, output_folder, language=None):
        """
        批量處理文件夾中的圖片
        
        參數(shù):
            input_folder (str): 輸入文件夾路徑
            output_folder (str): 輸出文件夾路徑
            language (str): 識別語言
        
        返回:
            list: 處理結(jié)果列表
        """
        if language is None:
            language = self.default_language
        
        # 創(chuàng)建輸出文件夾
        os.makedirs(output_folder, exist_ok=True)
        
        # 獲取所有圖片文件
        image_extensions = ['*.png', '*.jpg', '*.jpeg', '*.bmp', '*.tiff']
        image_paths = []
        for extension in image_extensions:
            image_paths.extend(glob.glob(os.path.join(input_folder, extension)))
        
        results = []
        
        for image_path in image_paths:
            filename = os.path.splitext(os.path.basename(image_path))[0]
            
            print(f"處理圖片: {os.path.basename(image_path)}")
            
            try:
                # 提取文本
                text = self.extract_text(image_path, language=language)
                
                # 保存文本結(jié)果
                output_text_path = os.path.join(output_folder, f"{filename}.txt")
                with open(output_text_path, 'w', encoding='utf-8') as f:
                    f.write(text)
                
                # 保存帶邊界框的圖像
                output_image_path = os.path.join(output_folder, f"{filename}_boxes.png")
                box_data = self.extract_text_with_boxes(
                    image_path, 
                    language=language, 
                    output_image_path=output_image_path
                )
                
                results.append({
                    'file': os.path.basename(image_path),
                    'text': text,
                    'boxes': box_data['text_boxes'],
                    'success': True
                })
                
            except Exception as e:
                print(f"處理圖片 {image_path} 時出錯: {str(e)}")
                results.append({
                    'file': os.path.basename(image_path),
                    'error': str(e),
                    'success': False
                })
        
        # 生成處理報告
        report_path = os.path.join(output_folder, "processing_report.txt")
        with open(report_path, 'w', encoding='utf-8') as f:
            f.write("OCR處理報告\n")
            f.write("=" * 50 + "\n")
            successful = sum(1 for r in results if r['success'])
            f.write(f"成功處理: {successful}/{len(results)} 個文件\n\n")
            
            for result in results:
                f.write(f"文件: {result['file']}\n")
                if result['success']:
                    f.write(f"狀態(tài): 成功\n")
                    f.write(f"提取字符數(shù): {len(result['text'])}\n")
                else:
                    f.write(f"狀態(tài): 失敗 - {result['error']}\n")
                f.write("-" * 30 + "\n")
        
        print(f"批量處理完成，報告已保存到: {report_path}")
        return results

# 使用示例
if __name__ == "__main__":
    # 創(chuàng)建OCR實例
    ocr = AdvancedOCR(default_language='eng+chi_sim')
    
    # 單張圖片處理
    result = ocr.extract_text("sample.png")
    print("識別結(jié)果:")
    print(result)
    
    # 批量處理
    # results = ocr.batch_process("input_images", "output_results")