import random
from PIL import Image, ImageDraw, ImageFont, ImageFilter
import numpy as np
from pathlib import Path

class SyntheticOCRDataGenerator:
    def __init__(
        self,
        fonts_dir,
        backgrounds_dir=None,
        image_height=64,
        image_width=800,
        charset="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 .,!?'-"
    ):
        """
        Generate synthetic OCR training data with realistic variations.

        Args:
            fonts_dir: Directory containing .ttf font files
            backgrounds_dir: Optional directory with background textures
            image_height: Target image height
            image_width: Target image width
            charset: Valid character set for text generation
        """
        self.fonts = list(Path(fonts_dir).glob("*.ttf"))
        self.backgrounds = (
            list(Path(backgrounds_dir).glob("*.png")) +
            list(Path(backgrounds_dir).glob("*.jpg"))
            if backgrounds_dir else []
        )
        self.image_height = image_height
        self.image_width = image_width
        self.charset = charset

        # Realistic corpus for text sampling
        self.corpus = self._load_corpus()

    def _load_corpus(self):
        """Load or generate text corpus for sampling."""
        # In production, load from actual text files
        # Here we use placeholder common English words
        return [
            "the", "and", "for", "are", "but", "not", "you", "all",
            "can", "her", "was", "one", "our", "out", "day", "get",
            "has", "him", "his", "how", "man", "new", "now", "old",
            "see", "time", "very", "when", "your", "come", "made",
            "may", "part", "over", "such", "take", "than", "that",
            "their", "there", "these", "they", "this", "what", "when"
        ]

    def generate_sample(self):
        """
        Generate a single synthetic OCR sample.

        Returns:
            Tuple of (image, text) where image is PIL.Image and text is string
        """
        # Generate random text
        num_words = random.randint(3, 12)
        text = " ".join(random.choices(self.corpus, k=num_words))

        # Select random font
        font_path = random.choice(self.fonts)
        font_size = random.randint(28, 48)
        font = ImageFont.truetype(str(font_path), font_size)

        # Create base image
        if self.backgrounds and random.random() < 0.3:
            # Use real background texture
            bg = Image.open(random.choice(self.backgrounds)).convert('L')
            bg = bg.resize((self.image_width, self.image_height))
            image = bg.copy()
        else:
            # Generate synthetic background
            bg_color = random.randint(235, 255)
            image = Image.new('L', (self.image_width, self.image_height), bg_color)

        draw = ImageDraw.Draw(image)

        # Calculate text position
        bbox = draw.textbbox((0, 0), text, font=font)
        text_width = bbox[2] - bbox[0]
        text_height = bbox[3] - bbox[1]

        # Ensure text fits
        if text_width > self.image_width - 20:
            # Reduce font size if text is too long
            font_size = int(font_size * (self.image_width - 20) / text_width)
            font = ImageFont.truetype(str(font_path), font_size)
            bbox = draw.textbbox((0, 0), text, font=font)
            text_width = bbox[2] - bbox[0]
            text_height = bbox[3] - bbox[1]

        x = random.randint(10, max(10, self.image_width - text_width - 10))
        y = (self.image_height - text_height) // 2 + random.randint(-5, 5)

        # Text color
        text_color = random.randint(0, 50)

        # Draw text
        draw.text((x, y), text, font=font, fill=text_color)

        # Apply augmentations
        image = self._apply_augmentations(image)

        return image, text

    def _apply_augmentations(self, image):
        """
        Apply realistic augmentations to synthetic images.

        Args:
            image: PIL Image

        Returns:
            Augmented PIL Image
        """
        # Gaussian blur (simulate focus issues)
        if random.random() < 0.3:
            blur_radius = random.uniform(0.5, 1.5)
            image = image.filter(ImageFilter.GaussianBlur(blur_radius))

        # Salt and pepper noise (simulate scanning artifacts)
        if random.random() < 0.25:
            img_array = np.array(image)
            noise_mask = np.random.random(img_array.shape)
            img_array[noise_mask < 0.01] = 255  # Salt
            img_array[noise_mask > 0.99] = 0    # Pepper
            image = Image.fromarray(img_array)

        # Slight rotation (simulate page skew)
        if random.random() < 0.4:
            angle = random.uniform(-2, 2)
            image = image.rotate(angle, fillcolor=255, expand=False)

        # Contrast and brightness variation
        if random.random() < 0.5:
            img_array = np.array(image).astype(np.float32)
            contrast = random.uniform(0.8, 1.2)
            brightness = random.uniform(-20, 20)
            img_array = img_array * contrast + brightness
            img_array = np.clip(img_array, 0, 255).astype(np.uint8)
            image = Image.fromarray(img_array)

        return image

    def generate_dataset(self, num_samples, output_dir):
        """
        Generate complete synthetic dataset.

        Args:
            num_samples: Number of samples to generate
            output_dir: Directory to save images and labels
        """
        output_path = Path(output_dir)
        output_path.mkdir(parents=True, exist_ok=True)

        images_dir = output_path / "images"
        images_dir.mkdir(exist_ok=True)

        labels_file = output_path / "labels.txt"

        with open(labels_file, 'w', encoding='utf-8') as f:
            for i in range(num_samples):
                image, text = self.generate_sample()

                image_filename = f"sample_{i:06d}.png"
                image_path = images_dir / image_filename
                image.save(image_path)

                f.write(f"{image_filename}\t{text}\n")

                if (i + 1) % 1000 == 0:
                    print(f"Generated {i + 1}/{num_samples} samples")


# Usage example
if __name__ == "__main__":
    generator = SyntheticOCRDataGenerator(
        fonts_dir="/usr/share/fonts/truetype",
        backgrounds_dir="./backgrounds"
    )

    generator.generate_dataset(
        num_samples=50000,
        output_dir="./synthetic_ocr_data"
    )

import cv2
import numpy as np
from typing import Tuple

class OCRPreprocessor:
    def __init__(
        self,
        target_height=64,
        target_width=None,
        normalize=True,
        binarize=False,
        denoise=True
    ):
        """
        Preprocessing pipeline for OCR images.

        Args:
            target_height: Target height for resizing
            target_width: Target width (None for aspect ratio preservation)
            normalize: Apply normalization to [0, 1] or [-1, 1]
            binarize: Apply Otsu's binarization
            denoise: Apply denoising filter
        """
        self.target_height = target_height
        self.target_width = target_width
        self.normalize = normalize
        self.binarize = binarize
        self.denoise = denoise

    def preprocess(self, image_path: str) -> Tuple[np.ndarray, float]:
        """
        Preprocess an image for OCR inference or training.

        Args:
            image_path: Path to input image

        Returns:
            Tuple of (preprocessed_image, aspect_ratio)
        """
        # Load image as grayscale
        img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

        if img is None:
            raise ValueError(f"Failed to load image: {image_path}")

        # Store original aspect ratio
        original_height, original_width = img.shape
        aspect_ratio = original_width / original_height

        # Denoising
        if self.denoise:
            img = cv2.fastNlMeansDenoising(img, h=10)

        # [Binarization](/articles/image-binarization-methods)
        if self.binarize:
            _, img = cv2.threshold(
                img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU
            )

        # Resize while preserving aspect ratio
        if self.target_width is None:
            # Calculate width to preserve aspect ratio
            new_width = int(self.target_height * aspect_ratio)
        else:
            new_width = self.target_width

        img = cv2.resize(
            img,
            (new_width, self.target_height),
            interpolation=cv2.INTER_CUBIC
        )

        # Normalize to [0, 1]
        img = img.astype(np.float32) / 255.0

        if self.normalize:
            # Normalize to [-1, 1] for better gradient flow
            img = (img - 0.5) / 0.5

        return img, aspect_ratio

    def batch_preprocess(
        self,
        image_paths: list,
        pad_to_max=True
    ) -> Tuple[np.ndarray, list]:
        """
        Preprocess a batch of images with optional padding.

        Args:
            image_paths: List of image file paths
            pad_to_max: Pad all images to maximum width in batch

        Returns:
            Tuple of (batch_array, aspect_ratios)
        """
        processed_images = []
        aspect_ratios = []

        for path in image_paths:
            img, ratio = self.preprocess(path)
            processed_images.append(img)
            aspect_ratios.append(ratio)

        if pad_to_max and self.target_width is None:
            # Find maximum width in batch
            max_width = max(img.shape[1] for img in processed_images)

            # Pad all images to max width
            padded_images = []
            for img in processed_images:
                if img.shape[1] < max_width:
                    pad_width = max_width - img.shape[1]
                    img = np.pad(
                        img,
                        ((0, 0), (0, pad_width)),
                        mode='constant',
                        constant_values=1.0 if self.normalize else 255
                    )
                padded_images.append(img)

            processed_images = padded_images

        # Stack into batch array
        batch = np.stack(processed_images, axis=0)

        # Add channel dimension for grayscale
        batch = np.expand_dims(batch, axis=1)  # (batch, 1, height, width)

        return batch, aspect_ratios

import editdistance
import numpy as np
from typing import List, Dict

class OCRMetrics:
    @staticmethod
    def calculate_cer(predictions: List[str], ground_truths: List[str]) -> float:
        """
        Calculate Character Error Rate across a dataset.

        Args:
            predictions: List of predicted text strings
            ground_truths: List of ground truth text strings

        Returns:
            Character Error Rate as percentage
        """
        total_chars = 0
        total_errors = 0

        for pred, gt in zip(predictions, ground_truths):
            total_chars += len(gt)
            total_errors += editdistance.eval(pred, gt)

        cer = (total_errors / total_chars) * 100 if total_chars > 0 else 0
        return cer

    @staticmethod
    def calculate_wer(predictions: List[str], ground_truths: List[str]) -> float:
        """
        Calculate Word Error Rate across a dataset.

        Args:
            predictions: List of predicted text strings
            ground_truths: List of ground truth text strings

        Returns:
            Word Error Rate as percentage
        """
        total_words = 0
        total_errors = 0

        for pred, gt in zip(predictions, ground_truths):
            pred_words = pred.split()
            gt_words = gt.split()

            total_words += len(gt_words)
            total_errors += editdistance.eval(pred_words, gt_words)

        wer = (total_errors / total_words) * 100 if total_words > 0 else 0
        return wer

    @staticmethod
    def calculate_accuracy(predictions: List[str], ground_truths: List[str]) -> float:
        """
        Calculate exact match accuracy (percentage of perfect predictions).

        Args:
            predictions: List of predicted text strings
            ground_truths: List of ground truth text strings

        Returns:
            Accuracy as percentage
        """
        correct = sum(
            pred.strip() == gt.strip()
            for pred, gt in zip(predictions, ground_truths)
        )
        accuracy = (correct / len(predictions)) * 100 if predictions else 0
        return accuracy

    @staticmethod
    def calculate_normalized_edit_distance(
        predictions: List[str],
        ground_truths: List[str]
    ) -> float:
        """
        Calculate average normalized edit distance (1 - CER/100).

        Args:
            predictions: List of predicted text strings
            ground_truths: List of ground truth text strings

        Returns:
            Normalized edit distance (0-1, higher is better)
        """
        distances = []

        for pred, gt in zip(predictions, ground_truths):
            if len(gt) == 0:
                distance = 0.0 if len(pred) == 0 else 1.0
            else:
                edit_dist = editdistance.eval(pred, gt)
                distance = 1.0 - (edit_dist / len(gt))
            distances.append(max(0.0, distance))

        return np.mean(distances) * 100

    @staticmethod
    def comprehensive_evaluation(
        predictions: List[str],
        ground_truths: List[str]
    ) -> Dict[str, float]:
        """
        Calculate all OCR metrics for comprehensive evaluation.

        Args:
            predictions: List of predicted text strings
            ground_truths: List of ground truth text strings

        Returns:
            Dictionary containing all metrics
        """
        return {
            'CER': OCRMetrics.calculate_cer(predictions, ground_truths),
            'WER': OCRMetrics.calculate_wer(predictions, ground_truths),
            'Accuracy': OCRMetrics.calculate_accuracy(predictions, ground_truths),
            'Normalized_ED': OCRMetrics.calculate_normalized_edit_distance(
                predictions, ground_truths
            ),
            'Total_Samples': len(predictions)
        }

import optuna
from optuna.trial import Trial
import torch
import torch.nn as nn
from torch.utils.data import DataLoader

def objective(trial: Trial) -> float:
    """
    Optuna objective function for hyperparameter optimization.

    Args:
        trial: Optuna trial object

    Returns:
        Validation Character Error Rate (to minimize)
    """
    # Suggest hyperparameters
    learning_rate = trial.suggest_float('learning_rate', 1e-5, 1e-2, log=True)
    batch_size = trial.suggest_categorical('batch_size', [8, 16, 32, 64])
    hidden_size = trial.suggest_categorical('hidden_size', [256, 512, 768, 1024])
    num_layers = trial.suggest_int('num_layers', 1, 4)
    dropout = trial.suggest_float('dropout', 0.1, 0.5)
    weight_decay = trial.suggest_float('weight_decay', 1e-6, 1e-3, log=True)

    # Create model with suggested hyperparameters
    model = create_model(
        hidden_size=hidden_size,
        num_layers=num_layers,
        dropout=dropout
    )

    # Create optimizer
    optimizer = torch.optim.AdamW(
        model.parameters(),
        lr=learning_rate,
        weight_decay=weight_decay
    )

    # Train for limited epochs
    num_epochs = 10
    best_val_cer = float('inf')

    for epoch in range(num_epochs):
        # Training phase
        train_loss = train_epoch(model, train_loader, optimizer)

        # Validation phase
        val_cer = evaluate_model(model, val_loader)

        # Report intermediate value for pruning
        trial.report(val_cer, epoch)

        # Pruning: stop unpromising trials early
        if trial.should_prune():
            raise optuna.TrialPruned()

        best_val_cer = min(best_val_cer, val_cer)

    return best_val_cer


# Run hyperparameter optimization
study = optuna.create_study(
    direction='minimize',
    pruner=optuna.pruners.MedianPruner(n_startup_trials=5)
)

study.optimize(objective, n_trials=50, timeout=36000)

print("Best hyperparameters:", study.best_params)
print("Best validation CER:", study.best_value)