import cv2
import numpy as np

def segment_characters(binary_image):
    """
    Segment printed characters using connected components.
    Works well for printed text with clear character boundaries.
    """
    # Find connected components
    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(
        binary_image, connectivity=8
    )

    characters = []
    for i in range(1, num_labels):  # Skip background (label 0)
        x, y, w, h, area = stats[i]

        # Filter noise by size
        if w > 5 and h > 10 and area > 20:
            char_image = binary_image[y:y+h, x:x+w]
            characters.append({
                'image': char_image,
                'bbox': (x, y, w, h),
                'position': x  # For sorting
            })

    # Sort characters left-to-right
    characters.sort(key=lambda c: c['position'])

    return characters

import torch
import torch.nn as nn

class HTRModel(nn.Module):
    """
    HTR sequence-to-sequence model using CNN + LSTM + CTC.
    No character segmentation required.
    """
    def __init__(self, num_chars=80, hidden_size=256):
        super().__init__()

        # CNN feature extractor
        self.cnn = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )

        # Bidirectional LSTM for sequence modeling
        self.lstm = nn.LSTM(
            input_size=128,
            hidden_size=hidden_size,
            num_layers=2,
            bidirectional=True,
            batch_first=True
        )

        # Output layer for CTC decoding
        self.output = nn.Linear(hidden_size * 2, num_chars + 1)  # +1 for CTC blank

    def forward(self, x):
        # Extract CNN features
        features = self.cnn(x)

        # Reshape for LSTM: (batch, seq_len, feature_dim)
        b, c, h, w = features.size()
        features = features.permute(0, 3, 1, 2).reshape(b, w, c * h)

        # LSTM sequence modeling
        lstm_out, _ = self.lstm(features)

        # Character predictions
        output = self.output(lstm_out)

        return output

import time
from PIL import Image
import pytesseract  # OCR
from transformers import TrOCRProcessor, VisionEncoderDecoderModel  # Can be adapted for HTR

def compare_performance(image_path):
    """
    Compare processing speed of OCR vs HTR approaches.
    """
    image = Image.open(image_path).convert('RGB')

    # OCR: Tesseract (character-based)
    start = time.time()
    ocr_text = pytesseract.image_to_string(image)
    ocr_time = time.time() - start

    # HTR-style: TrOCR (sequence-based)
    processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
    model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten')

    start = time.time()
    pixel_values = processor(image, return_tensors='pt').pixel_values
    generated_ids = model.generate(pixel_values)
    htr_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
    htr_time = time.time() - start

    return {
        'ocr': {'text': ocr_text, 'time': ocr_time},
        'htr': {'text': htr_text, 'time': htr_time},
        'speedup': htr_time / ocr_time
    }

# Typical results:
# OCR: 0.2-0.5 seconds per page
# HTR: 1.0-3.0 seconds per page
# HTR is 4-10x slower than OCR

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

def ocr_pipeline(image_path):
    """
    Production-ready OCR pipeline with preprocessing.
    Optimized for printed documents.
    """
    # Load image
    image = cv2.imread(image_path)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # [Preprocessing for OCR](/articles/preprocessing-techniques)
    # Denoise
    denoised = cv2.fastNlMeansDenoising(gray)

    # [Binarization](/articles/image-binarization-methods)
    binary = cv2.adaptiveThreshold(
        denoised, 255,
        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
        cv2.THRESH_BINARY,
        11, 2
    )

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

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

    # OCR with configuration
    custom_config = r'--oem 3 --psm 6'  # LSTM OCR, assume uniform text block
    text = pytesseract.image_to_string(
        rotated,
        config=custom_config
    )

    # Get confidence scores
    data = pytesseract.image_to_data(
        rotated,
        output_type=pytesseract.Output.DICT,
        config=custom_config
    )

    avg_confidence = np.mean([
        int(conf) for conf in data['conf'] if conf != '-1'
    ])

    return {
        'text': text.strip(),
        'confidence': avg_confidence,
        'word_count': len(text.split())
    }

import torch
from torch.nn import CTCLoss
import numpy as np

def htr_pipeline(image_path, model, char_map):
    """
    HTR pipeline for handwritten text recognition.
    Uses sequence-to-sequence approach with CTC loss.
    """
    # Load and preprocess image for HTR
    image = Image.open(image_path).convert('L')  # Grayscale

    # Normalize to fixed height (preserve aspect ratio)
    target_height = 64
    aspect_ratio = image.width / image.height
    target_width = int(target_height * aspect_ratio)
    image = image.resize((target_width, target_height))

    # Convert to tensor
    img_tensor = torch.FloatTensor(np.array(image)) / 255.0
    img_tensor = img_tensor.unsqueeze(0).unsqueeze(0)  # Add batch and channel dims

    # Forward pass through HTR model
    with torch.no_grad():
        output = model(img_tensor)  # Shape: (1, seq_len, num_classes)

    # CTC decoding
    output = output.log_softmax(2)
    output = output.permute(1, 0, 2)  # (seq_len, batch, num_classes)

    # Greedy decoding
    _, max_indices = torch.max(output, dim=2)

    # Remove consecutive duplicates and blanks
    decoded = []
    prev_idx = None
    for idx in max_indices[:, 0].tolist():
        if idx != prev_idx and idx != len(char_map):  # Not blank token
            decoded.append(char_map[idx])
        prev_idx = idx

    predicted_text = ''.join(decoded)

    # Calculate confidence (average probability of predicted characters)
    probs = torch.exp(output)
    confidence = torch.gather(
        probs, 2,
        max_indices.unsqueeze(2)
    ).mean().item() * 100

    return {
        'text': predicted_text,
        'confidence': confidence,
        'sequence_length': len(decoded)
    }