Tesseract OCR Implementation Guide: From Installation to Production

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

# Install language packs
sudo apt install tesseract-ocr-eng  # English
sudo apt install tesseract-ocr-deu  # German
sudo apt install tesseract-ocr-fra  # French

sudo vi /etc/apt/sources.list
# Add: deb http://archive.ubuntu.com/ubuntu bionic universe
sudo apt update

brew install tesseract

# Language data automatically included
# Additional languages available via:
brew install tesseract-lang

sudo port install tesseract

# Install specific languages:
sudo port install tesseract-<langcode>

FROM ubuntu:22.04

RUN apt-get update && apt-get install -y \
    tesseract-ocr \
    tesseract-ocr-eng \
    tesseract-ocr-deu \
    tesseract-ocr-fra \
    libtesseract-dev \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY . .

CMD ["tesseract", "--help"]

# Download custom traineddata
wget https://github.com/tesseract-ocr/tessdata/raw/main/custom.traineddata

# Install to tessdata directory
sudo cp custom.traineddata /usr/share/tesseract-ocr/4.00/tessdata/

# Verify installation
tesseract --list-langs

tesseract imagename outputbase [-l lang] [--oem ocrenginemode] [--psm pagesegmode] [configfiles...]

# Single uniform block of text
tesseract document.png output --psm 6

# Single text line
tesseract single_line.png output --psm 7

# Single word
tesseract word.png output --psm 8

# Automatic page segmentation (default)
tesseract document.png output --psm 3

# Plain text output
tesseract input.png output txt

# hOCR (HTML) with position information
tesseract input.png output hocr

# PDF with searchable text layer
tesseract input.png output pdf

# TSV format with confidence scores
tesseract input.png output tsv

# ALTO XML format
tesseract input.png output alto

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

class TesseractProcessor:
    def __init__(self, lang='eng', oem=1, psm=3):
        self.config = f'--oem {oem} --psm {psm}'
        self.lang = lang

    def preprocess_image(self, image_path):
        """Optimize image for OCR accuracy using standardized preprocessing"""
        image = cv2.imread(image_path)
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

        # Noise reduction with Gaussian blur
        denoised = cv2.GaussianBlur(gray, (5, 5), 0)

        # Otsu's thresholding for binarization
        _, thresh = cv2.threshold(denoised, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

        # Automatic deskewing via cv2.minAreaRect rotation correction
        coords = np.column_stack(np.where(thresh > 0))
        angle = cv2.minAreaRect(coords)[-1]
        if angle < -45:
            angle = -(90 + angle)
        else:
            angle = -angle

        (h, w) = thresh.shape[:2]
        center = (w // 2, h // 2)
        M = cv2.getRotationMatrix2D(center, angle, 1.0)
        rotated = cv2.warpAffine(thresh, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)

        return rotated

    def extract_with_confidence(self, image_path):
        """Extract text with confidence scores"""
        processed_image = self.preprocess_image(image_path)

        # Get detailed data including confidence
        data = pytesseract.image_to_data(
            processed_image, 
            lang=self.lang,
            config=self.config,
            output_type=pytesseract.Output.DICT
        )

        # Filter by confidence threshold
        confident_text = []
        for i, conf in enumerate(data['conf']):
            if int(conf) > 60:  # Confidence threshold
                text = data['text'][i].strip()
                if text:
                    confident_text.append({
                        'text': text,
                        'confidence': conf,
                        'bbox': {
                            'x': data['left'][i],
                            'y': data['top'][i],
                            'width': data['width'][i],
                            'height': data['height'][i]
                        }
                    })

        return confident_text

import os
import concurrent.futures
from pathlib import Path
import json
from datetime import datetime

class BatchTesseractProcessor:
    def __init__(self, max_workers=4):
        self.max_workers = max_workers
        self.processor = TesseractProcessor()

    def process_directory(self, input_dir, output_dir):
        """Process all images in directory with parallel execution"""
        input_path = Path(input_dir)
        output_path = Path(output_dir)
        output_path.mkdir(exist_ok=True)

        image_files = list(input_path.glob('*.{png,jpg,jpeg,tiff}'))

        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            futures = []

            for image_file in image_files:
                future = executor.submit(
                    self._process_single_file,
                    image_file,
                    output_path / f"{image_file.stem}.json"
                )
                futures.append(future)

            # Collect results
            results = []
            for future in concurrent.futures.as_completed(futures):
                try:
                    result = future.result()
                    results.append(result)
                except Exception as e:
                    print(f"Processing error: {e}")

            return results

    def _process_single_file(self, input_file, output_file):
        """Process single file and save results"""
        extracted_data = self.processor.extract_with_confidence(str(input_file))

        with open(output_file, 'w') as f:
            json.dump({
                'source_file': str(input_file),
                'extracted_text': extracted_data,
                'processing_timestamp': datetime.now().isoformat()
            }, f, indent=2)

        return output_file

def optimize_for_ocr(image_path):
    """Comprehensive image optimization for OCR"""
    image = cv2.imread(image_path)

    # Convert to grayscale
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Deskew correction using minAreaRect
    coords = np.column_stack(np.where(gray > 0))
    angle = cv2.minAreaRect(coords)[-1]
    if angle < -45:
        angle = -(90 + angle)
    else:
        angle = -angle

    (h, w) = gray.shape[:2]
    center = (w // 2, h // 2)
    M = cv2.getRotationMatrix2D(center, angle, 1.0)
    rotated = cv2.warpAffine(gray, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)

    # Noise reduction
    denoised = cv2.fastNlMeansDenoising(rotated)

    # Adaptive thresholding
    thresh = cv2.adaptiveThreshold(denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

    # Morphological operations to clean up
    kernel = np.ones((1,1), np.uint8)
    cleaned = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)

    return cleaned

class OptimizedTesseractService:
    def __init__(self, memory_limit_mb=512):
        self.memory_limit = memory_limit_mb * 1024 * 1024
        self.process_pool = None

    def configure_tesseract_environment(self):
        """Optimize Tesseract for production use"""
        os.environ['OMP_THREAD_LIMIT'] = '2'  # Limit OpenMP threads
        os.environ['TESSDATA_PREFIX'] = '/usr/share/tesseract-ocr/4.00/tessdata'

        # Custom config for speed optimization
        self.custom_config = (
            '--tessdata-dir /usr/share/tesseract-ocr/4.00/tessdata '
            '--oem 1 --psm 3 '
            '-c tessedit_char_whitelist=0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz '
            '-c preserve_interword_spaces=1'
        )

    def process_with_memory_management(self, image_data):
        """Process with memory monitoring"""
        import psutil
        process = psutil.Process()

        if process.memory_info().rss > self.memory_limit:
            # Force garbage collection
            import gc
            gc.collect()

            if process.memory_info().rss > self.memory_limit:
                raise MemoryError("Memory limit exceeded")

        return pytesseract.image_to_string(
            image_data,
            config=self.custom_config
        )

from unstructured.partition.auto import partition
import layoutparser as lp

class StructuredDocumentProcessor:
    def __init__(self):
        self.layout_model = lp.Detectron2LayoutModel(
            'lp://PubLayNet/faster_rcnn_R_50_FPN_3x/config',
            extra_config=["MODEL.ROI_HEADS.SCORE_THRESH_TEST", 0.8],
            label_map={0: "Text", 1: "Title", 2: "List", 3:"Table", 4:"Figure"}
        )
        self.tesseract_agent = lp.TesseractAgent(languages='eng')

    def process_structured_document(self, image_path):
        """Extract text with layout understanding"""
        image = cv2.imread(image_path)
        layout = self.layout_model.detect(image)

        structured_content = {}

        for block in layout:
            # Extract text from each layout region
            segment_image = block.crop_image(image)
            text = self.tesseract_agent.detect(segment_image)

            structured_content[block.type] = {
                'text': text,
                'bbox': block.coordinates,
                'confidence': block.score
            }

        return structured_content

import logging
from datetime import datetime
import json

class EnterpriseOCRService:
    def __init__(self, config_path='ocr_config.json'):
        self.config = self._load_config(config_path)
        self.logger = self._setup_logging()

    def _setup_logging(self):
        """Configure enterprise logging"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('ocr_processing.log'),
                logging.StreamHandler()
            ]
        )
        return logging.getLogger(__name__)

    def process_document_with_audit(self, document_path, user_id=None):
        """Process document with full audit trail"""
        start_time = datetime.now()

        try:
            # Validate input
            if not os.path.exists(document_path):
                raise FileNotFoundError(f"Document not found: {document_path}")

            # Process document
            result = self._extract_text_with_metadata(document_path)

            # Log successful processing
            processing_time = (datetime.now() - start_time).total_seconds()

            audit_record = {
                'document_path': document_path,
                'user_id': user_id,
                'processing_time_seconds': processing_time,
                'status': 'success',
                'timestamp': start_time.isoformat(),
                'text_length': len(result.get('text', '')),
                'confidence_score': result.get('avg_confidence', 0)
            }

            self.logger.info(f"Document processed successfully: {json.dumps(audit_record)}")

            return {
                'success': True,
                'data': result,
                'audit': audit_record
            }

        except Exception as e:
            # Log processing error
            error_record = {
                'document_path': document_path,
                'user_id': user_id,
                'error': str(e),
                'status': 'error',
                'timestamp': start_time.isoformat()
            }

            self.logger.error(f"Document processing failed: {json.dumps(error_record)}")

            return {
                'success': False,
                'error': str(e),
                'audit': error_record
            }

from langdetect import detect
import pytesseract

def process_multilingual_document(image_path):
    """Handle documents with multiple languages"""
    # First pass with automatic language detection
    initial_text = pytesseract.image_to_string(Image.open(image_path))

    try:
        detected_lang = detect(initial_text)
        lang_map = {
            'en': 'eng',
            'de': 'deu', 
            'fr': 'fra',
            'es': 'spa'
        }

        tesseract_lang = lang_map.get(detected_lang, 'eng')

        # Reprocess with detected language
        optimized_text = pytesseract.image_to_string(
            Image.open(image_path),
            lang=tesseract_lang,
            config='--oem 1 --psm 3'
        )

        return {
            'text': optimized_text,
            'detected_language': detected_lang,
            'tesseract_language': tesseract_lang
        }

    except:
        # Fallback to English if detection fails
        return {
            'text': initial_text,
            'detected_language': 'unknown',
            'tesseract_language': 'eng'
        }

import time
import psutil
from collections import defaultdict

class OCRPerformanceMonitor:
    def __init__(self):
        self.metrics = defaultdict(list)

    def monitor_processing(self, func):
        """Decorator to monitor OCR processing performance"""
        def wrapper(*args, **kwargs):
            start_time = time.time()
            start_memory = psutil.Process().memory_info().rss

            try:
                result = func(*args, **kwargs)

                end_time = time.time()
                end_memory = psutil.Process().memory_info().rss

                # Record metrics
                self.metrics['processing_time'].append(end_time - start_time)
                self.metrics['memory_usage'].append(end_memory - start_memory)
                self.metrics['success_count'].append(1)

                return result

            except Exception as e:
                self.metrics['error_count'].append(1)
                raise e

        return wrapper

    def get_performance_summary(self):
        """Generate performance summary"""
        if not self.metrics['processing_time']:
            return "No processing data available"

        return {
            'avg_processing_time': sum(self.metrics['processing_time']) / len(self.metrics['processing_time']),
            'max_processing_time': max(self.metrics['processing_time']),
            'avg_memory_usage_mb': sum(self.metrics['memory_usage']) / len(self.metrics['memory_usage']) / 1024 / 1024,
            'success_rate': len(self.metrics['success_count']) / (len(self.metrics['success_count']) + len(self.metrics['error_count'])),
            'total_documents_processed': len(self.metrics['processing_time'])
        }