OCR은 Optical Character Recognition의 약자로, 우리말로는 '광학 문자 인식'이라고 해. 쉽게 말하면 이미지나 스캔한 문서에서 텍스트를 인식해서 컴퓨터가 편집할 수 있는 문자 데이터로 변환하는 기술이야. 📖➡️💻

예를 들어볼게. 옛날 책을 스캔했다고 생각해봐. 그냥 이미지 파일이면 검색도 안 되고, 복사도 안 되고, 번역도 안 되잖아? 그런데 OCR을 거치면 그 이미지 속 글자들이 진짜 텍스트로 변환되는 거지! 🎉

자, 이제 본격적으로 OCR 프로그램을 만들기 위해 뭐가 필요한지 알아보자! 프로그래밍 언어부터 라이브러리까지 하나씩 살펴볼게. 🔧

먼저 개발 환경을 구축해야 해. Python을 기준으로 설명할게. Python이 설치되어 있다고 가정하고 진행할게! 🐍

brew install tesseract

sudo apt-get install tesseract-ocr
sudo apt-get install libtesseract-dev

pip install pytesseract
pip install Pillow
pip install opencv-python
pip install numpy
pip install pdf2image

# Linux/Mac
sudo apt-get install tesseract-ocr-kor

# 또는 수동 다운로드
# https://github.com/tesseract-ocr/tessdata
# kor.traineddata 파일을 Tesseract의 tessdata 폴더에 복사

자, 이제 드디어 코드를 작성해볼 시간이야! 가장 기본적인 OCR 프로그램부터 시작해보자. 😎

import pytesseract
from PIL import Image

# Tesseract 실행 파일 경로 설정 (Windows의 경우)
# pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

def simple_ocr(image_path):
    """
    기본 OCR 함수
    
    Args:
        image_path: 이미지 파일 경로
    
    Returns:
        추출된 텍스트
    """
    try:
        # 이미지 열기
        image = Image.open(image_path)
        
        # OCR 수행 (한글 + 영어)
        text = pytesseract.image_to_string(image, lang='kor+eng')
        
        return text
    
    except Exception as e:
        return f"오류 발생: {str(e)}"

# 사용 예시
if __name__ == "__main__":
    image_path = "sample_document.jpg"
    result = simple_ocr(image_path)
    print("추출된 텍스트:")
    print(result)

기본 OCR만으로는 인식률이 낮을 수 있어. 특히 이미지 품질이 안 좋거나, 기울어져 있거나, 노이즈가 많으면 제대로 인식이 안 돼. 그래서 이미지 전처리가 정말 중요해! 🔍

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

class ImagePreprocessor:
    """이미지 전처리 클래스"""
    
    @staticmethod
    def convert_to_grayscale(image):
        """그레이스케일 변환"""
        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
    @staticmethod
    def apply_threshold(image):
        """이진화 처리 (흑백으로 명확하게)"""
        # Otsu's 이진화 방법 사용
        _, binary = cv2.threshold(
            image, 0, 255, 
            cv2.THRESH_BINARY + cv2.THRESH_OTSU
        )
        return binary
    
    @staticmethod
    def remove_noise(image):
        """노이즈 제거"""
        # 모폴로지 연산으로 노이즈 제거
        kernel = np.ones((1, 1), np.uint8)
        image = cv2.dilate(image, kernel, iterations=1)
        image = cv2.erode(image, kernel, iterations=1)
        
        # 가우시안 블러로 추가 노이즈 제거
        image = cv2.GaussianBlur(image, (5, 5), 0)
        
        return image
    
    @staticmethod
    def deskew(image):
        """기울어진 이미지 보정"""
        coords = np.column_stack(np.where(image > 0))
        angle = cv2.minAreaRect(coords)[-1]
        
        if angle < -45:
            angle = -(90 + angle)
        else:
            angle = -angle
        
        (h, w) = image.shape[:2]
        center = (w // 2, h // 2)
        M = cv2.getRotationMatrix2D(center, angle, 1.0)
        rotated = cv2.warpAffine(
            image, M, (w, h),
            flags=cv2.INTER_CUBIC,
            borderMode=cv2.BORDER_REPLICATE
        )
        
        return rotated
    
    @staticmethod
    def resize_image(image, scale_percent=150):
        """이미지 크기 조정 (해상도 향상)"""
        width = int(image.shape[1] * scale_percent / 100)
        height = int(image.shape[0] * scale_percent / 100)
        dim = (width, height)
        
        return cv2.resize(image, dim, interpolation=cv2.INTER_CUBIC)

def advanced_ocr(image_path, preprocess=True):
    """
    고급 OCR 함수 (전처리 포함)
    
    Args:
        image_path: 이미지 파일 경로
        preprocess: 전처리 수행 여부
    
    Returns:
        추출된 텍스트
    """
    # 이미지 읽기
    image = cv2.imread(image_path)
    
    if preprocess:
        preprocessor = ImagePreprocessor()
        
        # 1. 그레이스케일 변환
        gray = preprocessor.convert_to_grayscale(image)
        
        # 2. 노이즈 제거
        denoised = preprocessor.remove_noise(gray)
        
        # 3. 이진화
        binary = preprocessor.apply_threshold(denoised)
        
        # 4. 기울기 보정
        deskewed = preprocessor.deskew(binary)
        
        # 5. 해상도 향상
        resized = preprocessor.resize_image(deskewed)
        
        # PIL Image로 변환
        processed_image = Image.fromarray(resized)
    else:
        processed_image = Image.open(image_path)
    
    # OCR 수행
    custom_config = r'--oem 3 --psm 6'
    text = pytesseract.image_to_string(
        processed_image, 
        lang='kor+eng',
        config=custom_config
    )
    
    return text

# 사용 예시
if __name__ == "__main__":
    image_path = "document.jpg"
    
    print("=== 전처리 없이 OCR ===")
    result_basic = advanced_ocr(image_path, preprocess=False)
    print(result_basic)
    
    print("\n=== 전처리 후 OCR ===")
    result_advanced = advanced_ocr(image_path, preprocess=True)
    print(result_advanced)

실무에서는 이미지보다 PDF 문서를 처리하는 경우가 더 많아. PDF를 OCR로 처리하는 방법을 알아보자! 📄

from pdf2image import convert_from_path
import pytesseract
from PIL import Image
import os

class PDFOCRProcessor:
    """PDF OCR 처리 클래스"""
    
    def __init__(self, tesseract_path=None):
        if tesseract_path:
            pytesseract.pytesseract.tesseract_cmd = tesseract_path
    
    def pdf_to_images(self, pdf_path, dpi=300):
        """
        PDF를 이미지로 변환
        
        Args:
            pdf_path: PDF 파일 경로
            dpi: 해상도 (높을수록 품질 좋음, 기본 300)
        
        Returns:
            이미지 리스트
        """
        try:
            images = convert_from_path(pdf_path, dpi=dpi)
            return images
        except Exception as e:
            print(f"PDF 변환 오류: {str(e)}")
            return []
    
    def process_pdf(self, pdf_path, output_txt_path=None, lang='kor+eng'):
        """
        PDF 전체를 OCR 처리
        
        Args:
            pdf_path: PDF 파일 경로
            output_txt_path: 결과 텍스트 파일 경로 (선택)
            lang: 인식 언어
        
        Returns:
            추출된 전체 텍스트
        """
        print(f"PDF 처리 시작: {pdf_path}")
        
        # PDF를 이미지로 변환
        images = self.pdf_to_images(pdf_path)
        
        if not images:
            return "PDF 변환 실패"
        
        full_text = ""
        
        # 각 페이지 처리
        for i, image in enumerate(images, 1):
            print(f"페이지 {i}/{len(images)} 처리 중...")
            
            # OCR 수행
            page_text = pytesseract.image_to_string(image, lang=lang)
            
            # 페이지 구분자 추가
            full_text += f"\n{'='*50}\n"
            full_text += f"[페이지 {i}]\n"
            full_text += f"{'='*50}\n"
            full_text += page_text
            full_text += "\n"
        
        # 파일로 저장 (옵션)
        if output_txt_path:
            with open(output_txt_path, 'w', encoding='utf-8') as f:
                f.write(full_text)
            print(f"결과 저장 완료: {output_txt_path}")
        
        return full_text
    
    def process_pdf_with_preprocessing(self, pdf_path, output_txt_path=None):
        """전처리를 포함한 PDF OCR 처리"""
        import cv2
        import numpy as np
        
        images = self.pdf_to_images(pdf_path)
        full_text = ""
        
        for i, pil_image in enumerate(images, 1):
            print(f"페이지 {i}/{len(images)} 처리 중 (전처리 포함)...")
            
            # PIL Image를 OpenCV 형식으로 변환
            opencv_image = cv2.cvtColor(
                np.array(pil_image), 
                cv2.COLOR_RGB2BGR
            )
            
            # 전처리
            gray = cv2.cvtColor(opencv_image, cv2.COLOR_BGR2GRAY)
            denoised = cv2.fastNlMeansDenoising(gray)
            _, binary = cv2.threshold(
                denoised, 0, 255, 
                cv2.THRESH_BINARY + cv2.THRESH_OTSU
            )
            
            # 다시 PIL Image로 변환
            processed_image = Image.fromarray(binary)
            
            # OCR 수행
            page_text = pytesseract.image_to_string(
                processed_image, 
                lang='kor+eng'
            )
            
            full_text += f"\n[페이지 {i}]\n{page_text}\n"
        
        if output_txt_path:
            with open(output_txt_path, 'w', encoding='utf-8') as f:
                f.write(full_text)
        
        return full_text

# 사용 예시
if __name__ == "__main__":
    processor = PDFOCRProcessor()
    
    # 기본 PDF OCR
    pdf_path = "sample_document.pdf"
    output_path = "extracted_text.txt"
    
    result = processor.process_pdf(pdf_path, output_path)
    print("추출 완료!")
    print(result[:500])  # 처음 500자만 출력

이제 좀 더 고급 기술들을 알아볼까? 실무에서 정말 유용한 팁들이야! 💪

import pytesseract
from PIL import Image

class OptimizedOCR:
    """최적화된 OCR 클래스"""
    
    # PSM (Page Segmentation Mode) 모드
    PSM_MODES = {
        'auto': 3,           # 자동 페이지 분할
        'single_column': 4,  # 단일 컬럼
        'single_block': 6,   # 단일 텍스트 블록
        'single_line': 7,    # 한 줄 텍스트
        'single_word': 8,    # 단일 단어
        'sparse_text': 11,   # 희소 텍스트
    }
    
    # OEM (OCR Engine Mode) 모드
    OEM_MODES = {
        'legacy': 0,         # 레거시 엔진
        'lstm': 1,           # LSTM 신경망 엔진
        'legacy_lstm': 2,    # 레거시 + LSTM
        'default': 3,        # 기본값
    }
    
    @staticmethod
    def ocr_with_config(image_path, psm_mode='single_block', 
                       oem_mode='default', lang='kor+eng',
                       whitelist=None, blacklist=None):
        """
        설정을 커스터마이징한 OCR
        
        Args:
            image_path: 이미지 경로
            psm_mode: 페이지 분할 모드
            oem_mode: OCR 엔진 모드
            lang: 언어
            whitelist: 허용할 문자들 (예: '0123456789' - 숫자만)
            blacklist: 제외할 문자들
        
        Returns:
            추출된 텍스트
        """
        image = Image.open(image_path)
        
        # 설정 문자열 생성
        psm = OptimizedOCR.PSM_MODES.get(psm_mode, 6)
        oem = OptimizedOCR.OEM_MODES.get(oem_mode, 3)
        
        config = f'--oem {oem} --psm {psm}'
        
        # 화이트리스트/블랙리스트 추가
        if whitelist:
            config += f' -c tessedit_char_whitelist={whitelist}'
        if blacklist:
            config += f' -c tessedit_char_blacklist={blacklist}'
        
        # OCR 수행
        text = pytesseract.image_to_string(
            image, 
            lang=lang, 
            config=config
        )
        
        return text
    
    @staticmethod
    def ocr_with_confidence(image_path, lang='kor+eng'):
        """
        신뢰도 정보와 함께 OCR 수행
        
        Returns:
            딕셔너리 형태의 상세 정보
        """
        image = Image.open(image_path)
        
        # 상세 데이터 추출
        data = pytesseract.image_to_data(
            image, 
            lang=lang, 
            output_type=pytesseract.Output.DICT
        )
        
        # 신뢰도가 높은 텍스트만 필터링
        filtered_text = []
        for i, conf in enumerate(data['conf']):
            if int(conf) > 60:  # 신뢰도 60% 이상
                text = data['text'][i]
                if text.strip():
                    filtered_text.append({
                        'text': text,
                        'confidence': conf,
                        'position': {
                            'x': data['left'][i],
                            'y': data['top'][i],
                            'width': data['width'][i],
                            'height': data['height'][i]
                        }
                    })
        
        return filtered_text
    
    @staticmethod
    def extract_numbers_only(image_path):
        """숫자만 추출 (전화번호, 계좌번호 등)"""
        return OptimizedOCR.ocr_with_config(
            image_path,
            psm_mode='single_line',
            whitelist='0123456789-+()'
        )
    
    @staticmethod
    def extract_korean_only(image_path):
        """한글만 추출"""
        text = OptimizedOCR.ocr_with_config(
            image_path,
            lang='kor'
        )
        # 한글만 필터링
        import re
        korean_only = re.findall(r'[가-힣\s]+', text)
        return ' '.join(korean_only)

# 사용 예시
if __name__ == "__main__":
    ocr = OptimizedOCR()
    
    # 1. 일반 문서 (단일 블록)
    text1 = ocr.ocr_with_config(
        "document.jpg",
        psm_mode='single_block'
    )
    print("일반 문서:", text1)
    
    # 2. 명함 (희소 텍스트)
    text2 = ocr.ocr_with_config(
        "business_card.jpg",
        psm_mode='sparse_text'
    )
    print("명함:", text2)
    
    # 3. 전화번호 추출
    phone = ocr.extract_numbers_only("phone_number.jpg")
    print("전화번호:", phone)
    
    # 4. 신뢰도와 함께 추출
    detailed = ocr.ocr_with_confidence("document.jpg")
    for item in detailed[:5]:  # 처음 5개만
        print(f"텍스트: {item['text']}, 신뢰도: {item['confidence']}%")

이론만 배우면 재미없잖아? 실제로 활용할 수 있는 명함 인식 시스템을 만들어보자! 이건 정말 실용적이야. 😊

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

class BusinessCardOCR:
    """명함 인식 전문 클래스"""
    
    def __init__(self):
        self.patterns = {
            'email': r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
            'phone': r'0\d{1,2}[-\s]?\d{3,4}[-\s]?\d{4}',
            'mobile': r'01[0-9][-\s]?\d{3,4}[-\s]?\d{4}',
            'url': r'(?:www\.|https?://)[^\s]+',
        }
    
    def preprocess_card(self, image_path):
        """명함 이미지 전처리"""
        # 이미지 읽기
        image = cv2.imread(image_path)
        
        # 크기 조정 (너무 작으면 확대)
        height, width = image.shape[:2]
        if width < 1000:
            scale = 1000 / width
            new_width = int(width * scale)
            new_height = int(height * scale)
            image = cv2.resize(
                image, 
                (new_width, new_height), 
                interpolation=cv2.INTER_CUBIC
            )
        
        # 그레이스케일
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # 적응형 이진화 (명함은 조명이 불균일할 수 있음)
        binary = cv2.adaptiveThreshold(
            gray, 255,
            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
            cv2.THRESH_BINARY, 11, 2
        )
        
        # 노이즈 제거
        denoised = cv2.fastNlMeansDenoising(binary)
        
        return Image.fromarray(denoised)
    
    def extract_text(self, image_path):
        """명함에서 텍스트 추출"""
        # 전처리
        processed_image = self.preprocess_card(image_path)
        
        # OCR 수행 (희소 텍스트 모드)
        custom_config = r'--oem 3 --psm 11'
        text = pytesseract.image_to_string(
            processed_image,
            lang='kor+eng',
            config=custom_config
        )
        
        return text
    
    def parse_card_info(self, text):
        """추출된 텍스트에서 정보 파싱"""
        info = {
            'name': None,
            'company': None,
            'position': None,
            'email': None,
            'phone': None,
            'mobile': None,
            'address': None,
            'url': None,
            'raw_text': text
        }
        
        lines = [line.strip() for line in text.split('\n') if line.strip()]
        
        # 이메일 찾기
        email_match = re.search(self.patterns['email'], text)
        if email_match:
            info['email'] = email_match.group()
        
        # 전화번호 찾기
        phone_match = re.search(self.patterns['phone'], text)
        if phone_match:
            info['phone'] = phone_match.group()
        
        # 휴대폰 번호 찾기
        mobile_match = re.search(self.patterns['mobile'], text)
        if mobile_match:
            info['mobile'] = mobile_match.group()
        
        # URL 찾기
        url_match = re.search(self.patterns['url'], text)
        if url_match:
            info['url'] = url_match.group()
        
        # 이름 추정 (한글 2-4자)
        korean_names = re.findall(r'\b[가-힣]{2,4}\b', text)
        if korean_names:
            info['name'] = korean_names[0]
        
        # 직책 키워드
        positions = ['대표', '이사', '부장', '차장', '과장', '대리', 
                    '사원', '팀장', '실장', 'CEO', 'CTO', 'CFO']
        for line in lines:
            for pos in positions:
                if pos in line:
                    info['position'] = line
                    break
        
        # 회사명 추정 (주식회사, (주), 등)
        company_keywords = ['주식회사', '(주)', '㈜', 'Inc', 'Corp', 'Co']
        for line in lines:
            for keyword in company_keywords:
                if keyword in line:
                    info['company'] = line
                    break
        
        return info
    
    def process_business_card(self, image_path):
        """명함 전체 처리 파이프라인"""
        print(f"명함 처리 시작: {image_path}")
        
        # 텍스트 추출
        text = self.extract_text(image_path)
        
        # 정보 파싱
        info = self.parse_card_info(text)
        
        return info
    
    def format_output(self, info):
        """결과를 보기 좋게 포맷팅"""
        output = "\n" + "="*50 + "\n"
        output += "📇 명함 정보\n"
        output += "="*50 + "\n\n"
        
        if info['name']:
            output += f"👤 이름: {info['name']}\n"
        if info['company']:
            output += f"🏢 회사: {info['company']}\n"
        if info['position']:
            output += f"💼 직책: {info['position']}\n"
        if info['email']:
            output += f"📧 이메일: {info['email']}\n"
        if info['phone']:
            output += f"☎️  전화: {info['phone']}\n"
        if info['mobile']:
            output += f"📱 휴대폰: {info['mobile']}\n"
        if info['url']:
            output += f"🌐 웹사이트: {info['url']}\n"
        
        output += "\n" + "="*50 + "\n"
        output += "📝 원본 텍스트:\n"
        output += "="*50 + "\n"
        output += info['raw_text']
        
        return output

# 사용 예시
if __name__ == "__main__":
    ocr = BusinessCardOCR()
    
    # 명함 처리
    card_info = ocr.process_business_card("business_card.jpg")
    
    # 결과 출력
    formatted = ocr.format_output(card_info)
    print(formatted)
    
    # JSON으로 저장하고 싶다면
    import json
    with open('card_info.json', 'w', encoding='utf-8') as f:
        json.dump(card_info, f, ensure_ascii=False, indent=2)

Tesseract도 좋지만, 최신 딥러닝 모델을 사용하면 훨씬 더 정확한 결과를 얻을 수 있어! 특히 손글씨나 복잡한 레이아웃에서 강력해. 🧠

# EasyOCR 설치
# pip install easyocr

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

class DeepLearningOCR:
    """딥러닝 기반 OCR 클래스"""
    
    def __init__(self, languages=['ko', 'en'], gpu=False):
        """
        초기화
        
        Args:
            languages: 인식할 언어 리스트
            gpu: GPU 사용 여부
        """
        print("EasyOCR 모델 로딩 중... (처음엔 시간이 걸릴 수 있어요)")
        self.reader = easyocr.Reader(languages, gpu=gpu)
        print("모델 로딩 완료!")
    
    def recognize_text(self, image_path, detail=1):
        """
        텍스트 인식
        
        Args:
            image_path: 이미지 경로
            detail: 0=텍스트만, 1=상세정보 포함
        
        Returns:
            인식 결과
        """
        result = self.reader.readtext(image_path, detail=detail)
        return result
    
    def extract_text_only(self, image_path):
        """텍스트만 추출"""
        results = self.reader.readtext(image_path, detail=1)
        texts = [text for (bbox, text, conf) in results]
        return '\n'.join(texts)
    
    def extract_with_confidence(self, image_path, min_confidence=0.5):
        """신뢰도 필터링하여 추출"""
        results = self.reader.readtext(image_path, detail=1)
        
        filtered = []
        for (bbox, text, conf) in results:
            if conf >= min_confidence:
                filtered.append({
                    'text': text,
                    'confidence': conf,
                    'bbox': bbox
                })
        
        return filtered
    
    def visualize_results(self, image_path, output_path='result.jpg'):
        """
        인식 결과를 이미지에 시각화
        """
        # 이미지 읽기
        image = cv2.imread(image_path)
        results = self.reader.readtext(image_path)
        
        # 각 텍스트 영역에 박스 그리기
        for (bbox, text, conf) in results:
            # 좌표 추출
            top_left = tuple(map(int, bbox[0]))
            bottom_right = tuple(map(int, bbox[2]))
            
            # 박스 그리기
            cv2.rectangle(image, top_left, bottom_right, (0, 255, 0), 2)
            
            # 텍스트 표시
            cv2.putText(
                image, text, 
                (top_left[0], top_left[1] - 10),
                cv2.FONT_HERSHEY_SIMPLEX, 
                0.8, (0, 255, 0), 2
            )
        
        # 저장
        cv2.imwrite(output_path, image)
        print(f"결과 이미지 저장: {output_path}")
        
        return image
    
    def compare_with_tesseract(self, image_path):
        """Tesseract와 비교"""
        import pytesseract
        
        # EasyOCR
        easy_text = self.extract_text_only(image_path)
        
        # Tesseract
        tess_text = pytesseract.image_to_string(
            Image.open(image_path), 
            lang='kor+eng'
        )
        
        return {
            'easyocr': easy_text,
            'tesseract': tess_text
        }

# 사용 예시
if __name__ == "__main__":
    # 모델 초기화 (한국어 + 영어)
    ocr = DeepLearningOCR(languages=['ko', 'en'], gpu=False)
    
    image_path = "document.jpg"
    
    # 1. 기본 텍스트 추출
    print("=== 텍스트 추출 ===")
    text = ocr.extract_text_only(image_path)
    print(text)
    
    # 2. 신뢰도와 함께 추출
    print("\n=== 상세 정보 ===")
    detailed = ocr.extract_with_confidence(image_path, min_confidence=0.7)
    for item in detailed:
        print(f"텍스트: {item['text']}")
        print(f"신뢰도: {item['confidence']:.2%}")
        print(f"위치: {item['bbox']}\n")
    
    # 3. 시각화
    ocr.visualize_results(image_path, 'result_visualized.jpg')
    
    # 4. Tesseract와 비교
    print("\n=== 엔진 비교 ===")
    comparison = ocr.compare_with_tesseract(image_path)
    print("EasyOCR 결과:")
    print(comparison['easyocr'])
    print("\nTesseract 결과:")
    print(comparison['tesseract'])

실무에서 OCR을 사용할 때 꼭 알아야 할 최적화 기법들을 알려줄게! 🚀

import concurrent.futures
import pytesseract
from PIL import Image
import os

class BatchOCRProcessor:
    """배치 OCR 처리 클래스"""
    
    def __init__(self, max_workers=4):
        self.max_workers = max_workers
    
    def process_single_image(self, image_path):
        """단일 이미지 처리"""
        try:
            image = Image.open(image_path)
            text = pytesseract.image_to_string(image, lang='kor+eng')
            return {
                'file': image_path,
                'text': text,
                'status': 'success'
            }
        except Exception as e:
            return {
                'file': image_path,
                'text': None,
                'status': 'error',
                'error': str(e)
            }
    
    def process_batch(self, image_paths):
        """배치 처리 (멀티스레딩)"""
        results = []
        
        with concurrent.futures.ThreadPoolExecutor(
            max_workers=self.max_workers
        ) as executor:
            # 모든 작업 제출
            future_to_path = {
                executor.submit(self.process_single_image, path): path 
                for path in image_paths
            }
            
            # 결과 수집
            for future in concurrent.futures.as_completed(future_to_path):
                result = future.result()
                results.append(result)
                print(f"처리 완료: {result['file']}")
        
        return results
    
    def process_directory(self, directory_path, extensions=['.jpg', '.png']):
        """디렉토리 내 모든 이미지 처리"""
        image_paths = []
        
        for filename in os.listdir(directory_path):
            if any(filename.lower().endswith(ext) for ext in extensions):
                full_path = os.path.join(directory_path, filename)
                image_paths.append(full_path)
        
        print(f"총 {len(image_paths)}개 이미지 발견")
        return self.process_batch(image_paths)

# 사용 예시
processor = BatchOCRProcessor(max_workers=4)
results = processor.process_directory('./images')

# 결과 저장
for result in results:
    if result['status'] == 'success':
        output_file = result['file'].replace('.jpg', '.txt')
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write(result['text'])

import hashlib
import pickle
import os

class CachedOCR:
    """캐싱 기능이 있는 OCR"""
    
    def __init__(self, cache_dir='./ocr_cache'):
        self.cache_dir = cache_dir
        os.makedirs(cache_dir, exist_ok=True)
    
    def get_file_hash(self, file_path):
        """파일 해시 계산"""
        with open(file_path, 'rb') as f:
            return hashlib.md5(f.read()).hexdigest()
    
    def get_cache_path(self, file_hash):
        """캐시 파일 경로"""
        return os.path.join(self.cache_dir, f"{file_hash}.pkl")
    
    def ocr_with_cache(self, image_path):
        """캐시를 활용한 OCR"""
        # 파일 해시 계산
        file_hash = self.get_file_hash(image_path)
        cache_path = self.get_cache_path(file_hash)
        
        # 캐시 확인
        if os.path.exists(cache_path):
            print(f"캐시에서 로드: {image_path}")
            with open(cache_path, 'rb') as f:
                return pickle.load(f)
        
        # OCR 수행
        print(f"OCR 처리 중: {image_path}")
        image = Image.open(image_path)
        text = pytesseract.image_to_string(image, lang='kor+eng')
        
        # 캐시 저장
        with open(cache_path, 'wb') as f:
            pickle.dump(text, f)
        
        return text

# 사용
cached_ocr = CachedOCR()
text = cached_ocr.ocr_with_cache('document.jpg')  # 첫 실행: OCR 수행
text = cached_ocr.ocr_with_cache('document.jpg')  # 두 번째: 캐시에서 로드

import logging
from datetime import datetime

class RobustOCR:
    """견고한 OCR 시스템"""
    
    def __init__(self, log_file='ocr.log'):
        # 로거 설정
        self.logger = logging.getLogger('OCR')
        self.logger.setLevel(logging.INFO)
        
        # 파일 핸들러
        fh = logging.FileHandler(log_file, encoding='utf-8')
        fh.setLevel(logging.INFO)
        
        # 포맷터
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        fh.setFormatter(formatter)
        
        self.logger.addHandler(fh)
    
    def safe_ocr(self, image_path, max_retries=3):
        """안전한 OCR (재시도 포함)"""
        for attempt in range(max_retries):
            try:
                self.logger.info(f"OCR 시도 {attempt + 1}/{max_retries}: {image_path}")
                
                # 이미지 열기
                image = Image.open(image_path)
                
                # 이미지 검증
                if image.size[0] < 100 or image.size[1] < 100:
                    raise ValueError("이미지가 너무 작습니다")
                
                # OCR 수행
                text = pytesseract.image_to_string(image, lang='kor+eng')
                
                # 결과 검증
                if not text.strip():
                    self.logger.warning(f"텍스트가 추출되지 않음: {image_path}")
                    return None
                
                self.logger.info(f"OCR 성공: {image_path} ({len(text)} 글자)")
                return text
                
            except FileNotFoundError:
                self.logger.error(f"파일을 찾을 수 없음: {image_path}")
                return None
                
            except Exception as e:
                self.logger.error(f"OCR 오류 (시도 {attempt + 1}): {str(e)}")
                
                if attempt == max_retries - 1:
                    self.logger.error(f"최종 실패: {image_path}")
                    return None
                
                # 재시도 전 대기
                import time
                time.sleep(1)
        
        return None

# 사용
robust_ocr = RobustOCR()
result = robust_ocr.safe_ocr('document.jpg')

CLI도 좋지만, GUI가 있으면 훨씬 사용하기 편하잖아? Tkinter로 간단한 OCR GUI를 만들어보자! 🖥️

import tkinter as tk
from tkinter import filedialog, scrolledtext, messagebox
from PIL import Image, ImageTk
import pytesseract
import cv2
import numpy as np

class OCRApplication:
    """OCR GUI 애플리케이션"""
    
    def __init__(self, root):
        self.root = root
        self.root.title("📄 문서 OCR 프로그램")
        self.root.geometry("1000x700")
        
        self.current_image_path = None
        self.create_widgets()
    
    def create_widgets(self):
        """위젯 생성"""
        # 상단 프레임 (버튼들)
        top_frame = tk.Frame(self.root, bg='#f0f0f0', pady=10)
        top_frame.pack(fill=tk.X)
        
        tk.Button(
            top_frame, 
            text="📁 이미지 열기",
            command=self.open_image,
            bg='#4CAF50',
            fg='white',
            font=('Arial', 12, 'bold'),
            padx=20,
            pady=10
        ).pack(side=tk.LEFT, padx=10)
        
        tk.Button(
            top_frame,
            text="🔍 OCR 실행",
            command=self.run_ocr,
            bg='#2196F3',
            fg='white',
            font=('Arial', 12, 'bold'),
            padx=20,
            pady=10
        ).pack(side=tk.LEFT, padx=10)
        
        tk.Button(
            top_frame,
            text="💾 텍스트 저장",
            command=self.save_text,
            bg='#FF9800',
            fg='white',
            font=('Arial', 12, 'bold'),
            padx=20,
            pady=10
        ).pack(side=tk.LEFT, padx=10)
        
        # 중앙 프레임 (이미지 + 텍스트)
        center_frame = tk.Frame(self.root)
        center_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 왼쪽: 이미지 표시
        left_frame = tk.LabelFrame(
            center_frame, 
            text="이미지 미리보기",
            font=('Arial', 10, 'bold')
        )
        left_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5)
        
        self.image_label = tk.Label(left_frame, bg='white')
        self.image_label.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 오른쪽: 텍스트 결과
        right_frame = tk.LabelFrame(
            center_frame,
            text="추출된 텍스트",
            font=('Arial', 10, 'bold')
        )
        right_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=5)
        
        self.text_area = scrolledtext.ScrolledText(
            right_frame,
            wrap=tk.WORD,
            font=('Arial', 11),
            bg='#ffffff'
        )
        self.text_area.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 하단 상태바
        self.status_bar = tk.Label(
            self.root,
            text="준비",
            bd=1,
            relief=tk.SUNKEN,
            anchor=tk.W,
            bg='#e0e0e0'
        )
        self.status_bar.pack(side=tk.BOTTOM, fill=tk.X)
    
    def open_image(self):
        """이미지 파일 열기"""
        file_path = filedialog.askopenfilename(
            title="이미지 선택",
            filetypes=[
                ("이미지 파일", "*.jpg *.jpeg *.png *.bmp"),
                ("모든 파일", "*.*")
            ]
        )
        
        if file_path:
            self.current_image_path = file_path
            self.display_image(file_path)
            self.status_bar.config(text=f"이미지 로드됨: {file_path}")
    
    def display_image(self, image_path):
        """이미지 표시"""
        # 이미지 로드
        image = Image.open(image_path)
        
        # 크기 조정 (최대 400x400)
        image.thumbnail((400, 400), Image.Resampling.LANCZOS)
        
        # Tkinter 이미지로 변환
        photo = ImageTk.PhotoImage(image)
        
        # 라벨에 표시
        self.image_label.config(image=photo)
        self.image_label.image = photo  # 참조 유지
    
    def run_ocr(self):
        """OCR 실행"""
        if not self.current_image_path:
            messagebox.showwarning("경고", "먼저 이미지를 선택하세요!")
            return
        
        self.status_bar.config(text="OCR 처리 중...")
        self.root.update()
        
        try:
            # 이미지 전처리
            image = cv2.imread(self.current_image_path)
            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
            _, binary = cv2.threshold(
                gray, 0, 255,
                cv2.THRESH_BINARY + cv2.THRESH_OTSU
            )
            
            # PIL Image로 변환
            pil_image = Image.fromarray(binary)
            
            # OCR 수행
            text = pytesseract.image_to_string(
                pil_image,
                lang='kor+eng'
            )
            
            # 결과 표시
            self.text_area.delete(1.0, tk.END)
            self.text_area.insert(tk.END, text)
            
            self.status_bar.config(
                text=f"OCR 완료! ({len(text)} 글자 추출됨)"
            )
            
        except Exception as e:
            messagebox.showerror("오류", f"OCR 처리 중 오류 발생:\n{str(e)}")
            self.status_bar.config(text="오류 발생")
    
    def save_text(self):
        """텍스트 저장"""
        text = self.text_area.get(1.0, tk.END).strip()
        
        if not text:
            messagebox.showwarning("경고", "저장할 텍스트가 없습니다!")
            return
        
        file_path = filedialog.asksaveasfilename(
            defaultextension=".txt",
            filetypes=[("텍스트 파일", "*.txt"), ("모든 파일", "*.*")]
        )
        
        if file_path:
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(text)
            
            messagebox.showinfo("성공", "텍스트가 저장되었습니다!")
            self.status_bar.config(text=f"저장 완료: {file_path}")

# 실행
if __name__ == "__main__":
    root = tk.Tk()
    app = OCRApplication(root)
    root.mainloop()

이제 OCR 프로그램을 만들 수 있게 됐어! 이런 기술을 가지고 있으면 재능넷에서 정말 다양한 방식으로 활용할 수 있어. 🎯

예를 들면:
• 문서 디지털화 서비스 제공
• 명함 인식 앱 개발
• OCR 프로그램 커스터마이징
• 데이터 입력 자동화 솔루션
• OCR 기술 컨설팅

재능넷은 이런 프로그래밍 재능을 필요로 하는 사람들과 연결해주는 플랫폼이야. 너의 OCR 기술을 활용해서 다른 사람들을 도와주고, 동시에 수익도 창출할 수 있지! 😊

배운 내용을 활용해서 이런 프로젝트들을 만들어볼 수 있어! 🚀

와! 여기까지 정말 긴 여정이었어. 우리가 함께 배운 내용을 정리해보자면: 🎉

✅ OCR의 기본 개념과 원리
✅ Tesseract 설치 및 기본 사용법
✅ 이미지 전처리 기법들
✅ PDF 문서 처리
✅ 고급 설정 및 최적화
✅ 딥러닝 기반 OCR (EasyOCR)
✅ 실전 프로젝트 (명함 인식)
✅ GUI 프로그램 개발
✅ 성능 최적화 및 에러 처리

이제 너도 OCR 전문가야! 🎊 처음에는 어려워 보였지만, 하나씩 따라하다 보니 할 수 있게 됐지?

중요한 건 계속 연습하고 실험해보는 거야. 다양한 이미지로 테스트해보고, 전처리 파라미터를 조정해보고, 새로운 라이브러리도 시도해봐. 그러다 보면 점점 더 정확하고 빠른 OCR 시스템을 만들 수 있을 거야! 💪

그리고 이런 기술을 가지고 있으면 정말 많은 곳에서 활용할 수 있어. 회사 업무 자동화, 개인 프로젝트, 또는 재능넷 같은 플랫폼에서 프리랜서로 활동하는 것도 좋은 방법이지!