class GothicCharacterSet:
    """
    Comprehensive character set for Gothic script recognition.

    Includes standard characters, historical variants, ligatures,
    and abbreviation marks essential for accurate Gothic HTR.
    """

    # Basic lowercase (includes long s)
    LOWERCASE = [
        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
        'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
        'ſ'  # Long s (U+017F)
    ]

    # Basic uppercase
    UPPERCASE = [
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
        'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
    ]

    # Common ligatures (essential for German Fraktur)
    LIGATURES = [
        'ch', 'ck', 'ct', 'st', 'tz', 'ff', 'fi', 'fl',
        'ſs', 'ſſ', 'ſi', 'ſſi'  # Long s combinations
    ]

    # Diacritics and modified characters (German umlauts, etc.)
    DIACRITICS = [
        'ä', 'ö', 'ü', 'Ä', 'Ö', 'Ü', 'ß',  # German
        'å', 'æ', 'ø', 'Å', 'Æ', 'Ø',        # Scandinavian
        'á', 'é', 'í', 'ó', 'ú',             # Accented vowels
    ]

    # Medieval abbreviation marks
    ABBREVIATIONS = [
        '̃',   # Tilde (nasal suspension)
        '̄',   # Macron (omitted m/n)
        'ꝑ',  # P with stroke (per, par)
        'ꝓ',  # P with stroke through descender (pro)
        'ꝙ',  # Q with diagonal stroke (que, qui)
        '℞',  # Prescription sign (recipe)
        '℟',  # Response sign
    ]

    # Punctuation (including historical marks)
    PUNCTUATION = [
        '.', ',', ';', ':', '!', '?',
        '(', ')', '[', ']', '{', '}',
        '-', '–', '—',
        '"', '"', '"', "'", ''', ''',
        '/', '\\',
        '·',  # Middle dot (historical word separator)
    ]

    # Numerals
    NUMERALS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

    # Special tokens
    SPECIAL = [
        '<BLANK>',  # CTC blank token
        '<UNK>',    # Unknown character
        '<PAD>',    # Padding token
        '<SOS>',    # Start of sequence
        '<EOS>',    # End of sequence
    ]

    @classmethod
    def get_full_charset(cls):
        """
        Return complete character set as list.

        Returns:
            List of all characters in proper order
        """
        charset = (
            cls.SPECIAL +
            cls.LOWERCASE +
            cls.UPPERCASE +
            cls.LIGATURES +
            cls.DIACRITICS +
            cls.ABBREVIATIONS +
            cls.PUNCTUATION +
            cls.NUMERALS
        )
        return charset

    @classmethod
    def get_char_to_idx(cls):
        """
        Create character to index mapping.

        Returns:
            Dictionary mapping characters to indices
        """
        charset = cls.get_full_charset()
        return {char: idx for idx, char in enumerate(charset)}

    @classmethod
    def get_idx_to_char(cls):
        """
        Create index to character mapping.

        Returns:
            Dictionary mapping indices to characters
        """
        charset = cls.get_full_charset()
        return {idx: char for idx, char in enumerate(charset)}

    @classmethod
    def get_charset_size(cls):
        """Return total number of characters in set."""
        return len(cls.get_full_charset())


# Usage example
if __name__ == "__main__":
    print(f"Gothic character set size: {GothicCharacterSet.get_charset_size()}")
    print(f"Sample ligatures: {GothicCharacterSet.LIGATURES[:5]}")
    print(f"Abbreviation marks: {GothicCharacterSet.ABBREVIATIONS[:3]}")

import torch
import torch.nn as nn

class GothicScriptHTR(nn.Module):
    def __init__(
        self,
        num_classes,
        input_height=64,
        hidden_size=512,
        num_layers=3,
        dropout=0.3
    ):
        """
        Specialized HTR architecture for Gothic scripts.

        Combines ResNet-inspired CNN with bidirectional LSTM and
        attention mechanisms optimized for Gothic script characteristics.

        Args:
            num_classes: Size of character set (including special tokens)
            input_height: Height of input image strips
            hidden_size: LSTM hidden state size
            num_layers: Number of LSTM layers
            dropout: Dropout probability
        """
        super(GothicScriptHTR, self).__init__()

        # Feature extraction with residual connections
        # Deeper network needed for Gothic's complex letterforms
        self.conv_layers = nn.Sequential(
            # Block 1
            nn.Conv2d(1, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),

            # Block 2
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.MaxPool2d(2, 2),

            # Block 3
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.MaxPool2d((2, 1)),  # Reduce height only

            # Block 4
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d((2, 1)),  # Reduce height only
        )

        # Calculate LSTM input size
        # After 4 pooling layers: height / 16
        lstm_input_size = 512 * (input_height // 16)

        # Bidirectional LSTM for sequence modeling
        self.lstm = nn.LSTM(
            input_size=lstm_input_size,
            hidden_size=hidden_size,
            num_layers=num_layers,
            bidirectional=True,
            dropout=dropout if num_layers > 1 else 0,
            batch_first=True
        )

        # [Attention mechanism](/articles/attention-mechanisms-ocr)
        # Helps model focus on ambiguous Gothic characters
        self.attention = nn.Sequential(
            nn.Linear(hidden_size * 2, hidden_size),
            nn.Tanh(),
            nn.Linear(hidden_size, 1)
        )

        # Output layer
        self.fc = nn.Linear(hidden_size * 2, num_classes)

        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        """
        Forward pass through Gothic HTR network.

        Args:
            x: Input image tensor (batch, 1, height, width)

        Returns:
            Output logits (batch, sequence_length, num_classes)
        """
        # CNN feature extraction
        features = self.conv_layers(x)  # (batch, 512, h', w')

        # Reshape for LSTM
        batch, channels, height, width = features.size()
        features = features.permute(0, 3, 1, 2)  # (batch, w', 512, h')
        features = features.reshape(batch, width, channels * height)

        # LSTM sequence modeling
        lstm_out, _ = self.lstm(features)  # (batch, seq_len, hidden*2)

        # Apply dropout
        lstm_out = self.dropout(lstm_out)

        # Attention weights (optional, can be used for visualization)
        attention_weights = torch.softmax(
            self.attention(lstm_out).squeeze(-1), dim=1
        )

        # Output projection
        output = self.fc(lstm_out)  # (batch, seq_len, num_classes)

        return output, attention_weights


class GothicHTRWithCTC:
    def __init__(self, model, charset):
        """
        Wrapper for Gothic HTR model with CTC decoding.

        Args:
            model: GothicScriptHTR instance
            charset: GothicCharacterSet instance
        """
        self.model = model
        self.charset = charset
        self.char_to_idx = charset.get_char_to_idx()
        self.idx_to_char = charset.get_idx_to_char()
        self.ctc_loss = nn.CTCLoss(blank=0, zero_infinity=True)

    def decode_ctc(self, outputs, method='greedy'):
        """
        Decode CTC outputs to text strings.

        Args:
            outputs: Model output logits (batch, seq_len, num_classes)
            method: Decoding method ('greedy' or 'beam_search')

        Returns:
            List of decoded text strings
        """
        if method == 'greedy':
            return self._greedy_decode(outputs)
        elif method == 'beam_search':
            return self._beam_search_decode(outputs)

    def _greedy_decode(self, outputs):
        """
        Greedy CTC decoding (fastest, reasonably accurate).

        Args:
            outputs: Model output logits

        Returns:
            List of decoded strings
        """
        predictions = []
        outputs = outputs.softmax(2)
        _, max_indices = outputs.max(2)

        for sequence in max_indices:
            chars = []
            prev_idx = None

            for idx in sequence:
                idx = idx.item()
                # Skip blanks and consecutive repeats
                if idx != 0 and idx != prev_idx:
                    chars.append(self.idx_to_char[idx])
                prev_idx = idx

            predictions.append(''.join(chars))

        return predictions

    def _beam_search_decode(self, outputs, beam_width=10):
        """
        Beam search CTC decoding (slower, more accurate).

        Particularly beneficial for Gothic scripts where character
        confusion is common.

        Args:
            outputs: Model output logits
            beam_width: Number of beams to maintain

        Returns:
            List of decoded strings
        """
        # Simplified beam search implementation
        # Production systems should use optimized libraries like ctcdecode
        probabilities = outputs.softmax(2)
        predictions = []

        for seq_probs in probabilities:
            beams = [('', 1.0)]  # (prefix, probability)

            for time_step in seq_probs:
                new_beams = {}

                for prefix, prefix_prob in beams:
                    for idx, prob in enumerate(time_step):
                        prob = prob.item()

                        if idx == 0:  # Blank
                            # Extend with blank
                            new_prefix = prefix
                        else:
                            char = self.idx_to_char[idx]

                            # Check if this extends previous character
                            if prefix and prefix[-1] == char:
                                new_prefix = prefix
                            else:
                                new_prefix = prefix + char

                        # Accumulate probability
                        new_prob = prefix_prob * prob
                        if new_prefix in new_beams:
                            new_beams[new_prefix] = max(
                                new_beams[new_prefix], new_prob
                            )
                        else:
                            new_beams[new_prefix] = new_prob

                # Keep top beam_width beams
                beams = sorted(
                    new_beams.items(),
                    key=lambda x: x[1],
                    reverse=True
                )[:beam_width]

            # Return most probable sequence
            predictions.append(beams[0][0] if beams else '')

        return predictions

import cv2
import numpy as np
from PIL import Image, ImageDraw, ImageFont
import random

class GothicAugmentation:
    @staticmethod
    def add_historical_artifacts(image, probability=0.3):
        """
        Add realistic historical document artifacts.

        Args:
            image: PIL Image
            probability: Probability of applying each artifact

        Returns:
            Augmented PIL Image
        """
        img_array = np.array(image)

        # Ink bleed simulation
        if random.random() < probability:
            kernel = np.ones((2, 2), np.uint8)
            img_array = cv2.dilate(img_array, kernel, iterations=1)

        # Background spots and staining
        if random.random() < probability:
            for _ in range(random.randint(5, 15)):
                x = random.randint(0, img_array.shape[1] - 1)
                y = random.randint(0, img_array.shape[0] - 1)
                radius = random.randint(2, 8)
                color = random.randint(200, 240)
                cv2.circle(img_array, (x, y), radius, color, -1)

        # Ink fading
        if random.random() < probability:
            fade_factor = random.uniform(0.6, 0.9)
            img_array = img_array.astype(np.float32)
            img_array = (img_array * fade_factor + 255 * (1 - fade_factor))
            img_array = np.clip(img_array, 0, 255).astype(np.uint8)

        return Image.fromarray(img_array)

    @staticmethod
    def elastic_deformation(image, alpha=30, sigma=5):
        """
        Apply elastic deformations to simulate handwriting variation.

        Particularly important for Gothic cursive (Kurrent).

        Args:
            image: PIL Image
            alpha: Deformation intensity
            sigma: Gaussian kernel sigma

        Returns:
            Deformed PIL Image
        """
        img_array = np.array(image)
        shape = img_array.shape

        dx = cv2.GaussianBlur(
            (np.random.rand(*shape) * 2 - 1),
            (0, 0), sigma
        ) * alpha
        dy = cv2.GaussianBlur(
            (np.random.rand(*shape) * 2 - 1),
            (0, 0), sigma
        ) * alpha

        x, y = np.meshgrid(np.arange(shape[1]), np.arange(shape[0]))
        indices = (
            np.clip(y + dy, 0, shape[0] - 1).astype(np.int32),
            np.clip(x + dx, 0, shape[1] - 1).astype(np.int32)
        )

        deformed = img_array[indices]
        return Image.fromarray(deformed)