pip install pytesseract pillow opencv-python

brew install tesseract
# 安裝中文語言包
brew install tesseract-lang

sudo apt-get update
sudo apt-get install tesseract-ocr
sudo apt-get install tesseract-ocr-chi-sim  # 中文簡體語言包
sudo apt-get install tesseract-ocr-eng      # 英文語言包

tesseract --version
tesseract --list-langs  # 查看已安裝的語言包

pip install pytesseract pillow opencv-python numpy

import pytesseract
from PIL import Image
import os

# 如果Tesseract未添加到系統(tǒng)PATH，可以手動(dòng)指定路徑
# Windows示例：
# pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

# 創(chuàng)建一個(gè)簡單的測試圖片（這里假設(shè)有一張包含文字的圖片）
# 如果沒有，可以先創(chuàng)建一個(gè)臨時(shí)圖片用于測試
def test_tesseract():
    try:
        # 嘗試打開一張示例圖片，如果沒有就創(chuàng)建一個(gè)簡單的
        test_image = Image.new('RGB', (300, 100), color='white')
        # 這里無法直接畫文字，所以只是測試能否調(diào)用tesseract
        # 如果能獲取到版本信息，說明環(huán)境正常
        version = pytesseract.get_tesseract_version()
        print(f"Tesseract版本: {version}")
        print("環(huán)境配置成功！")
    except Exception as e:
        print(f"環(huán)境配置失敗: {e}")
        print("請(qǐng)檢查Tesseract是否正確安裝并添加到PATH")

test_tesseract()

import pytesseract
from PIL import Image

def ocr_basic(image_path):
    """
    基礎(chǔ)OCR識(shí)別
    """
    # 打開圖片
    image = Image.open(image_path)
    
    # 使用Tesseract進(jìn)行識(shí)別
    # lang='eng'指定使用英文語言包
    text = pytesseract.image_to_string(image, lang='eng')
    
    print("識(shí)別結(jié)果：")
    print(text)
    return text

# 使用示例
ocr_basic('sample.png')

text = pytesseract.image_to_string(image, lang='chi_sim')

text = pytesseract.image_to_string(image, lang='chi_sim+eng')

import cv2
import numpy as np
from PIL import Image
import pytesseract

def preprocess_image(image_path):
    """
    圖像預(yù)處理：灰度化、二值化、去噪
    """
    # 讀取圖像（使用OpenCV）
    img = cv2.imread(image_path)
    
    # 1. 灰度化
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 2. 去噪（高斯模糊）
    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
    # 3. 二值化（自適應(yīng)閾值，處理光照不均的情況）
    # 使用自適應(yīng)閾值，根據(jù)局部像素分布自動(dòng)確定閾值
    binary = cv2.adaptiveThreshold(
        blurred, 
        255, 
        cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
        cv2.THRESH_BINARY, 
        11,  # 塊大小
        2    # 常數(shù)
    )
    
    # 4. 可選：形態(tài)學(xué)操作，去除小的噪點(diǎn)
    kernel = np.ones((1, 1), np.uint8)
    opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
    
    return opening

def ocr_with_preprocess(image_path):
    """
    預(yù)處理后的OCR識(shí)別
    """
    # 預(yù)處理
    processed_img = preprocess_image(image_path)
    
    # OpenCV圖像（numpy數(shù)組）轉(zhuǎn)換為PIL Image
    pil_img = Image.fromarray(processed_img)
    
    # OCR識(shí)別
    text = pytesseract.image_to_string(pil_img, lang='eng')
    
    return text

# 對(duì)比實(shí)驗(yàn)：直接識(shí)別 vs 預(yù)處理后識(shí)別
def compare_ocr(image_path):
    print("=== 直接識(shí)別 ===")
    img_raw = Image.open(image_path)
    text_raw = pytesseract.image_to_string(img_raw, lang='eng')
    print(text_raw[:200])  # 只顯示前200字符
    
    print("\n=== 預(yù)處理后識(shí)別 ===")
    text_processed = ocr_with_preprocess(image_path)
    print(text_processed[:200])

# 使用示例
compare_ocr('noisy_text.jpg')

import cv2
import numpy as np
import math

def correct_skew(image):
    """
    校正圖像傾斜
    """
    # 轉(zhuǎn)換為灰度圖
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    # 二值化
    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    
    # 檢測邊緣
    edges = cv2.Canny(binary, 50, 150, apertureSize=3)
    
    # 霍夫變換檢測直線
    lines = cv2.HoughLinesP(edges, 1, np.pi/180, 100, minLineLength=100, maxLineGap=10)
    
    if lines is None:
        return image
    
    # 計(jì)算所有檢測到的直線的角度
    angles = []
    for line in lines:
        x1, y1, x2, y2 = line[0]
        angle = math.degrees(math.atan2(y2 - y1, x2 - x1))
        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)
    rotated = cv2.warpAffine(image, M, (w, h), flags=cv2.INTER_CUBIC, 
                             borderMode=cv2.BORDER_REPLICATE)
    
    return rotated

def ocr_with_config(image_path, psm=6):
    """
    使用自定義配置進(jìn)行OCR識(shí)別
    """
    image = Image.open(image_path)
    
    # 配置參數(shù)：--psm 6 表示將圖像視為一個(gè)統(tǒng)一的文本塊
    # --oem 3 表示使用默認(rèn)的OCR引擎模式
    custom_config = r'--oem 3 --psm {}'.format(psm)
    
    text = pytesseract.image_to_string(
        image, 
        lang='eng', 
        config=custom_config
    )
    
    return text

# 不同PSM模式的對(duì)比
def test_psm_modes(image_path):
    for psm in [6, 7, 8, 13]:
        text = ocr_with_config(image_path, psm)
        print(f"PSM模式 {psm}:")
        print(text[:100] + "...\n")

import cv2
import numpy as np
import pytesseract
from PIL import Image

def preprocess_captcha(image_path):
    """
    驗(yàn)證碼圖像預(yù)處理
    """
    # 讀取圖像
    img = cv2.imread(image_path)
    
    # 1. 灰度化
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 2. 去噪（中值濾波，對(duì)去除椒鹽噪聲效果好）
    denoised = cv2.medianBlur(gray, 3)
    
    # 3. 二值化（使用OTSU自動(dòng)閾值）
    _, binary = cv2.threshold(denoised, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    
    # 4. 形態(tài)學(xué)操作：去除小的噪點(diǎn)
    # 定義結(jié)構(gòu)元素
    kernel = np.ones((2, 2), np.uint8)
    # 開運(yùn)算（先腐蝕后膨脹），去除小的白色噪點(diǎn)
    opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
    
    # 5. 可選：膨脹操作，連接斷開的字符
    # kernel_dilate = np.ones((2, 2), np.uint8)
    # dilated = cv2.dilate(opening, kernel_dilate, iterations=1)
    
    return opening

def recognize_captcha(image_path):
    """
    識(shí)別驗(yàn)證碼
    """
    # 預(yù)處理
    processed = preprocess_captcha(image_path)
    
    # 轉(zhuǎn)換為PIL圖像
    pil_img = Image.fromarray(processed)
    
    # OCR配置：--psm 8（單個(gè)單詞），只允許數(shù)字和大寫字母
    # -c tessedit_char_whitelist=0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
    custom_config = r'--psm 8 -c tessedit_char_whitelist=0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    
    text = pytesseract.image_to_string(
        pil_img, 
        lang='eng', 
        config=custom_config
    )
    
    # 清理結(jié)果：去除空格和特殊字符
    text = ''.join(filter(str.isalnum, text))
    
    return text

# 使用示例
captcha_text = recognize_captcha('captcha.png')
print(f"驗(yàn)證碼識(shí)別結(jié)果：{captcha_text}")

def segment_and_recognize(image_path):
    """
    字符分割后識(shí)別
    """
    # 預(yù)處理
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    
    # 查找輪廓（每個(gè)字符的輪廓）
    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # 篩選輪廓：根據(jù)寬高比和面積過濾
    char_contours = []
    for contour in contours:
        x, y, w, h = cv2.boundingRect(contour)
        # 過濾太小的噪聲
        if w > 5 and h > 10 and w < 50 and h < 50:
            char_contours.append((x, y, w, h))
    
    # 按x坐標(biāo)排序（從左到右）
    char_contours.sort(key=lambda x: x[0])
    
    # 逐個(gè)識(shí)別
    result = ""
    for i, (x, y, w, h) in enumerate(char_contours):
        # 提取單個(gè)字符區(qū)域
        char_img = binary[y:y+h, x:x+w]
        
        # 可選：為字符添加邊框，方便識(shí)別
        char_with_border = cv2.copyMakeBorder(
            char_img, 5, 5, 5, 5, 
            cv2.BORDER_CONSTANT, value=0
        )
        
        # 轉(zhuǎn)換為PIL圖像
        pil_char = Image.fromarray(char_with_border)
        
        # 識(shí)別單個(gè)字符
        custom_config = r'--psm 10 -c tessedit_char_whitelist=0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        char_text = pytesseract.image_to_string(pil_char, config=custom_config).strip()
        
        if char_text:
            result += char_text
    
    return result

from concurrent.futures import ThreadPoolExecutor
import hashlib
import pickle
import os

class CaptchaRecognizer:
    """
    帶緩存的驗(yàn)證碼識(shí)別器
    """
    def __init__(self, cache_dir='captcha_cache'):
        self.cache_dir = cache_dir
        if not os.path.exists(cache_dir):
            os.makedirs(cache_dir)
    
    def _get_cache_key(self, image_path):
        """生成緩存鍵（基于圖片內(nèi)容的哈希）"""
        with open(image_path, 'rb') as f:
            img_data = f.read()
        return hashlib.md5(img_data).hexdigest()
    
    def _recognize(self, image_path):
        """實(shí)際的識(shí)別邏輯"""
        processed = preprocess_captcha(image_path)
        pil_img = Image.fromarray(processed)
        custom_config = r'--psm 8 -c tessedit_char_whitelist=0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        text = pytesseract.image_to_string(pil_img, config=custom_config)
        return text.strip()
    
    def recognize(self, image_path):
        """帶緩存的識(shí)別"""
        cache_key = self._get_cache_key(image_path)
        cache_file = os.path.join(self.cache_dir, cache_key)
        
        # 檢查緩存
        if os.path.exists(cache_file):
            with open(cache_file, 'rb') as f:
                return pickle.load(f)
        
        # 識(shí)別
        result = self._recognize(image_path)
        
        # 保存到緩存
        with open(cache_file, 'wb') as f:
            pickle.dump(result, f)
        
        return result
    
    def batch_recognize(self, image_paths, max_workers=4):
        """批量識(shí)別（并行處理）"""
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            results = list(executor.map(self.recognize, image_paths))
        return results

import os
import pytesseract
from PIL import Image
import pandas as pd
from concurrent.futures import ThreadPoolExecutor
import cv2
import numpy as np
from datetime import datetime

class BatchOCRProcessor:
    """
    批量OCR識(shí)別處理器
    """
    def __init__(self, input_dir, output_excel, lang='chi_sim+eng', use_preprocess=True):
        """
        初始化
        
        :param input_dir: 輸入圖片目錄
        :param output_excel: 輸出Excel文件路徑
        :param lang: OCR語言包
        :param use_preprocess: 是否使用預(yù)處理
        """
        self.input_dir = input_dir
        self.output_excel = output_excel
        self.lang = lang
        self.use_preprocess = use_preprocess
        
        # 支持的圖片格式
        self.image_extensions = ('.png', '.jpg', '.jpeg', '.bmp', '.tiff')
    
    def preprocess_image(self, image_path):
        """
        圖像預(yù)處理
        """
        # 讀取圖像
        img = cv2.imread(image_path)
        
        # 灰度化
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        
        # 去噪
        denoised = cv2.medianBlur(gray, 3)
        
        # 二值化（自適應(yīng)閾值）
        binary = cv2.adaptiveThreshold(
            denoised, 255, 
            cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
            cv2.THRESH_BINARY, 11, 2
        )
        
        # 轉(zhuǎn)換為PIL圖像
        return Image.fromarray(binary)
    
    def process_single_image(self, filename):
        """
        處理單張圖片
        """
        file_path = os.path.join(self.input_dir, filename)
        
        try:
            if self.use_preprocess:
                # 預(yù)處理后識(shí)別
                img = self.preprocess_image(file_path)
            else:
                # 直接識(shí)別
                img = Image.open(file_path)
            
            # 執(zhí)行OCR識(shí)別
            # 配置：嘗試不同的PSM模式，選擇最佳結(jié)果
            text = self.ocr_with_multiple_configs(img)
            
            return {
                '文件名': filename,
                '識(shí)別內(nèi)容': text,
                '狀態(tài)': '成功',
                '處理時(shí)間': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }
        except Exception as e:
            return {
                '文件名': filename,
                '識(shí)別內(nèi)容': '',
                '狀態(tài)': f'失敗: {str(e)}',
                '處理時(shí)間': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
            }
    
    def ocr_with_multiple_configs(self, img):
        """
        使用多種配置嘗試識(shí)別，返回最佳結(jié)果
        """
        # 嘗試不同的PSM模式
        psm_modes = [6, 7, 8, 13]
        results = []
        
        for psm in psm_modes:
            config = f'--psm {psm}'
            text = pytesseract.image_to_string(img, lang=self.lang, config=config)
            # 計(jì)算有效字符數(shù)（去除非字母數(shù)字字符）
            valid_chars = sum(c.isalnum() for c in text)
            results.append((valid_chars, text))
        
        # 返回有效字符最多的結(jié)果
        best_result = max(results, key=lambda x: x[0])
        return best_result[1].strip()
    
    def run(self, max_workers=4):
        """
        運(yùn)行批量處理
        """
        print(f"開始掃描目錄: {self.input_dir}")
        
        # 獲取所有圖片文件
        image_files = [
            f for f in os.listdir(self.input_dir) 
            if f.lower().endswith(self.image_extensions)
        ]
        
        print(f"找到 {len(image_files)} 個(gè)圖片文件")
        
        if not image_files:
            print("未找到圖片文件")
            return
        
        # 批量處理（并行）
        results = []
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = [executor.submit(self.process_single_image, f) for f in image_files]
            for i, future in enumerate(futures):
                result = future.result()
                results.append(result)
                print(f"進(jìn)度: {i+1}/{len(image_files)} - 已處理 {result['文件名']}")
        
        # 保存到Excel
        df = pd.DataFrame(results)
        df.to_excel(self.output_excel, index=False, engine='openpyxl')
        
        print(f"\n處理完成！結(jié)果已保存至: {self.output_excel}")
        print(f"成功: {len(df[df['狀態(tài)'] == '成功'])} 個(gè)，失敗: {len(df[df['狀態(tài)'] != '成功'])} 個(gè)")
        
        # 返回統(tǒng)計(jì)信息
        return df

# 使用示例
if __name__ == "__main__":
    processor = BatchOCRProcessor(
        input_dir='./images',           # 圖片目錄
        output_excel='./ocr_results.xlsx',  # 輸出Excel
        lang='chi_sim+eng',              # 中英文混合
        use_preprocess=True               # 啟用預(yù)處理
    )
    
    results_df = processor.run(max_workers=4)

# 安裝PaddleOCR
# pip install paddlepaddle paddleocr

from paddleocr import PaddleOCR

def ocr_with_paddle(image_path):
    """
    使用PaddleOCR識(shí)別
    """
    # 初始化OCR（首次運(yùn)行會(huì)下載模型）
    ocr = PaddleOCR(use_angle_cls=True, lang='ch')
    
    # 識(shí)別
    result = ocr.ocr(image_path, cls=True)
    
    # 提取文本
    text = ''
    for line in result:
        for word_info in line:
            text += word_info[1][0] + ' '
    
    return text

def postprocess_text(text, known_words=None):
    """
    后處理：清洗和校正識(shí)別結(jié)果
    """
    # 去除多余的空格和換行
    text = ' '.join(text.split())
    
    # 去除特殊字符，只保留字母、數(shù)字、中文和基本標(biāo)點(diǎn)
    import re
    text = re.sub(r'[^\u4e00-\u9fff\u0041-\u005a\u0061-\u007a\u0030-\u0039\s\.,;:!?()]', '', text)
    
    # 如果提供了已知詞匯表，可以進(jìn)行簡單的糾錯(cuò)
    if known_words:
        words = text.split()
        corrected = []
        for word in words:
            if word not in known_words:
                # 簡單糾錯(cuò)：查找最相似的已知詞
                # 這里可以集成更復(fù)雜的拼寫檢查算法
                pass
            corrected.append(word)
        text = ' '.join(corrected)
    
    return text

pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

def enhance_image(image_path):
    """
    圖像增強(qiáng)：銳化+超分辨率
    """
    img = cv2.imread(image_path)
    
    # 銳化
    kernel_sharpen = np.array([[-1,-1,-1],
                               [-1, 9,-1],
                               [-1,-1,-1]])
    sharpened = cv2.filter2D(img, -1, kernel_sharpen)
    
    # 放大（如果圖像太?。?
    height, width = sharpened.shape[:2]
    if width < 800 or height < 600:
        scale = max(800/width, 600/height)
        new_width = int(width * scale)
        new_height = int(height * scale)
        enlarged = cv2.resize(sharpened, (new_width, new_height), interpolation=cv2.INTER_CUBIC)
        return enlarged
    
    return sharpened