monocr 0.1.0__tar.gz

monocr-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.3
+Name: monocr
+Version: 0.1.0
+Summary: Optical Character Recognition for Mon text
+Keywords: mon,ocr,text-recognition
+Author: janakhpon
+Author-email: janakhpon <jnovaxer@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: pillow>=9.0.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: click>=8.0.0
+Requires-Python: >=3.11
+Project-URL: Repository, https://github.com/janakhpon/monocr
+Description-Content-Type: text/markdown
+
+# Mon OCR
+
+Optical Character Recognition for Mon (mnw) text.
+
+## Installation
+
+```bash
+pip install monocr | uv add monocr
+```
+
+## Quick Start
+
+```python
+from monocr import read_text, read_folder
+
+# Read text from a single image
+text = read_text("image.png")
+print(text)
+
+# Read all images in a folder
+results = read_folder("images/")
+for filename, text in results.items():
+    print(f"{filename}: {text}")
+```
+
+## Command Line
+
+```bash
+# Read single image
+monocr read image.png
+
+# Process folder
+monocr batch images/ --output results.json
+```
+
+## License
+
+MIT License

monocr-0.1.0/README.md

@@ -0,0 +1,38 @@
+# Mon OCR
+
+Optical Character Recognition for Mon (mnw) text.
+
+## Installation
+
+```bash
+pip install monocr | uv add monocr
+```
+
+## Quick Start
+
+```python
+from monocr import read_text, read_folder
+
+# Read text from a single image
+text = read_text("image.png")
+print(text)
+
+# Read all images in a folder
+results = read_folder("images/")
+for filename, text in results.items():
+    print(f"{filename}: {text}")
+```
+
+## Command Line
+
+```bash
+# Read single image
+monocr read image.png
+
+# Process folder
+monocr batch images/ --output results.json
+```
+
+## License
+
+MIT License

monocr-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "monocr"
+version = "0.1.0"
+description = "Optical Character Recognition for Mon text"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    { name = "janakhpon", email = "jnovaxer@gmail.com" }
+]
+license = { text = "MIT" }
+keywords = ["mon", "ocr", "text-recognition"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+    "Topic :: Text Processing :: Linguistic",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "torch>=2.0.0",
+    "torchvision>=0.15.0",
+    "pillow>=9.0.0",
+    "numpy>=1.21.0",
+    "click>=8.0.0",
+]
+
+
+[project.urls]
+Repository = "https://github.com/janakhpon/monocr"
+
+[project.scripts]
+monocr = "monocr.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.8.13,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+monocr = ["models/*"]
+

monocr-0.1.0/src/monocr/__init__.py

@@ -0,0 +1,90 @@
+"""
+Mon OCR - Optical Character Recognition for Mon text
+A production-ready OCR package for Mon script text recognition
+"""
+
+import os
+from pathlib import Path
+from .ocr import MonOCR
+from .inference import MonOCRInference
+
+__version__ = "0.1.0"
+__author__ = "janakhpon"
+__email__ = "jnovaxer@gmail.com"
+
+__all__ = ["MonOCR", "MonOCRInference", "read_text", "read_image", "read_folder"]
+
+
+def get_default_model_path():
+    """Get the path to the bundled default model"""
+    package_dir = Path(__file__).parent
+    model_path = package_dir / "models" / "monocr_v1_best.pt"
+    return str(model_path)
+
+
+# Global OCR instance for simple API
+_ocr_instance = None
+
+def _get_ocr():
+    """Get or create the global OCR instance"""
+    global _ocr_instance
+    if _ocr_instance is None:
+        _ocr_instance = MonOCR()
+    return _ocr_instance
+
+
+def read_text(image_path):
+    """
+    Read text from a single image - Simple API
+    
+    Args:
+        image_path: Path to image file
+        
+    Returns:
+        Extracted text string
+    """
+    return _get_ocr().read_text(image_path)
+
+
+def read_image(image_path):
+    """
+    Alias for read_text - Read text from a single image
+    
+    Args:
+        image_path: Path to image file
+        
+    Returns:
+        Extracted text string
+    """
+    return read_text(image_path)
+
+
+def read_folder(folder_path, extensions=None):
+    """
+    Read text from all images in a folder - Simple API
+    
+    Args:
+        folder_path: Path to folder containing images
+        extensions: List of file extensions to process (default: ['.png', '.jpg', '.jpeg'])
+        
+    Returns:
+        Dictionary mapping filename to extracted text
+    """
+    return _get_ocr().read_from_folder(folder_path, extensions)
+
+
+def load_ocr(model_path=None, model_type="crnn"):
+    """
+    Load OCR model with default settings (Advanced API)
+    
+    Args:
+        model_path: Path to trained model file (if None, uses bundled model)
+        model_type: Type of model ("crnn" or "trocr")
+    
+    Returns:
+        MonOCR instance
+    """
+    if model_path is None:
+        model_path = get_default_model_path()
+    
+    return MonOCR(model_path, model_type)

monocr-0.1.0/src/monocr/cli.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""
+Command Line Interface for Mon OCR
+"""
+
+import click
+import json
+from pathlib import Path
+from typing import List
+
+from .ocr import MonOCR
+from .inference import MonOCRInference
+from . import get_default_model_path
+
+@click.group()
+@click.version_option()
+def main():
+    """Mon OCR - Optical Character Recognition for Mon text"""
+    pass
+
+@main.command()
+@click.argument('image_path', type=click.Path(exists=True))
+@click.option('--model', '-m', help='Path to trained model file (default: uses bundled model)')
+@click.option('--model-type', type=click.Choice(['crnn', 'trocr']), default='crnn', help='Type of model to use')
+@click.option('--output', '-o', help='Output file to save results')
+def read(image_path: str, model: str, model_type: str, output: str):
+    """Read text from a single image"""
+    try:
+        if model is None:
+            model = get_default_model_path()
+        ocr = MonOCR(model, model_type)
+        
+        print("Processing image...")
+        text = ocr.read_text(image_path)
+        
+        print(f"\nExtracted text:")
+        print(text)
+        
+        if output:
+            result = {
+                'image_path': image_path,
+                'extracted_text': text,
+                'model_type': model_type
+            }
+            with open(output, 'w', encoding='utf-8') as f:
+                json.dump(result, f, ensure_ascii=False, indent=2)
+            print(f"\nResults saved to: {output}")
+            
+    except Exception as e:
+        print(f"Error: {e}")
+        raise click.Abort()
+
+@main.command()
+@click.argument('folder_path', type=click.Path(exists=True, file_okay=False))
+@click.option('--model', '-m', help='Path to trained model file (default: uses bundled model)')
+@click.option('--model-type', type=click.Choice(['crnn', 'trocr']), default='crnn', help='Type of model to use')
+@click.option('--output', '-o', help='Output file to save results')
+@click.option('--extensions', default='png,jpg,jpeg', help='File extensions to process (comma-separated)')
+def batch(folder_path: str, model: str, model_type: str, output: str, extensions: str):
+    """Read text from all images in a folder"""
+    try:
+        if model is None:
+            model = get_default_model_path()
+        ocr = MonOCR(model, model_type)
+        ext_list = [f'.{ext.strip()}' for ext in extensions.split(',')]
+        
+        print("Processing folder...")
+        results = ocr.read_from_folder(folder_path, ext_list)
+        
+        print("\nOCR Results:")
+        print("-" * 40)
+        for filename, text in results.items():
+            print(f"{filename}: {text}")
+        
+        if output:
+            with open(output, 'w', encoding='utf-8') as f:
+                json.dump(results, f, ensure_ascii=False, indent=2)
+            print(f"\nResults saved to: {output}")
+            
+    except Exception as e:
+        print(f"Error: {e}")
+        raise click.Abort()
+
+@main.command()
+@click.argument('image_path', type=click.Path(exists=True))
+@click.option('--model', '-m', help='Path to trained model file (default: uses bundled model)')
+@click.option('--model-type', type=click.Choice(['crnn', 'trocr']), default='crnn', help='Type of model to use')
+def confidence(image_path: str, model: str, model_type: str):
+    """Read text with confidence score"""
+    try:
+        ocr = MonOCRInference(model, model_type)
+        
+        print("Processing image...")
+        result = ocr.predict_with_confidence(image_path)
+        
+        print(f"\nExtracted text:")
+        print(result['text'])
+        print(f"\nConfidence: {result['confidence']:.2%}")
+            
+    except Exception as e:
+        print(f"Error: {e}")
+        raise click.Abort()
+
+if __name__ == '__main__':
+    main()

monocr-0.1.0/src/monocr/crnn_model.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CRNN Model Architecture for Mon OCR
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import glob
+import os
+from typing import List
+
+class CRNN(nn.Module):
+    """CRNN model for Mon OCR - matches the trained model architecture"""
+    
+    def __init__(self, num_classes):
+        super(CRNN, self).__init__()
+        # Enhanced CNN architecture for better capacity
+        self.cnn = nn.Sequential(
+            nn.Conv2d(1, 64, 3, 1, 1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),  # 64->32
+            nn.Conv2d(64, 128, 3, 1, 1),
+            nn.ReLU(),
+            nn.MaxPool2d(2, 2),  # 32->16
+            nn.Conv2d(128, 256, 3, 1, 1),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.Conv2d(256, 256, 3, 1, 1),
+            nn.ReLU(),
+            nn.MaxPool2d((2, 1), (2, 1)),  # 16->8
+            nn.Conv2d(256, 512, 3, 1, 1),
+            nn.BatchNorm2d(512),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, 3, 1, 1),
+            nn.ReLU(),
+            nn.MaxPool2d((2, 1), (2, 1)),  # 8->4
+            nn.Conv2d(512, 512, 3, 1, 1),
+            nn.BatchNorm2d(512),
+            nn.ReLU(),
+            nn.Conv2d(512, 512, (4, 1), 1, 0),  # 4->1
+            nn.ReLU(),
+        )
+        # Two LSTM layers for better sequence modeling
+        self.lstm1 = nn.LSTM(512, 256, bidirectional=True, batch_first=True)
+        self.lstm2 = nn.LSTM(512, 256, bidirectional=True, batch_first=True)
+        self.dropout = nn.Dropout(0.1)  # add dropout to prevent overfitting
+        self.fc = nn.Linear(512, num_classes)
+
+    def forward(self, x):
+        conv = self.cnn(x)
+        b, c, h, w = conv.size()
+        assert h == 1, "CNN height must be 1"
+        conv = conv.squeeze(2).permute(0, 2, 1)  # [B, W, C]
+        
+        # Two LSTM layers for better sequence modeling
+        recurrent, _ = self.lstm1(conv)
+        recurrent, _ = self.lstm2(recurrent)
+        
+        # Apply dropout before final classification
+        recurrent = self.dropout(recurrent)
+        out = self.fc(recurrent)
+        return out  # [B, W, num_classes]
+
+def build_charset(corpus_dir: str) -> str:
+    """Build charset from corpus files"""
+    charset = set()
+    txt_files = glob.glob(os.path.join(corpus_dir, "**/*.txt"), recursive=True)
+    
+    for fpath in txt_files:
+        if os.path.getsize(fpath) == 0:
+            continue
+        try:
+            with open(fpath, encoding="utf-8") as f:
+                for line in f:
+                    charset.update(line.strip())
+        except Exception:
+            continue
+    
+    charset_str = "".join(sorted(list(charset)))
+    return charset_str

monocr-0.1.0/src/monocr/inference.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Advanced inference utilities for Mon OCR
+"""
+
+import os
+import torch
+import numpy as np
+from PIL import Image
+from pathlib import Path
+import json
+import logging
+from typing import List, Dict, Optional, Union
+
+from .ocr import MonOCR
+
+class MonOCRInference:
+    """Advanced Mon OCR inference with additional utilities"""
+    
+    def __init__(self, model_path: Optional[str] = None, model_type: str = "crnn"):
+        """
+        Initialize advanced Mon OCR inference
+        
+        Args:
+            model_path: Path to trained model file
+            model_type: Type of model ("crnn" or "trocr")
+        """
+        self.ocr = MonOCR(model_path, model_type)
+        self.logger = logging.getLogger(__name__)
+    
+    def predict_with_confidence(self, image: Union[str, Image.Image]) -> Dict[str, Union[str, float]]:
+        """
+        Predict text with confidence score
+        
+        Args:
+            image: Path to image file or PIL Image object
+            
+        Returns:
+            Dictionary with 'text' and 'confidence' keys
+        """
+        try:
+            text = self.ocr.predict(image)
+            # For now, return a placeholder confidence score
+            # In a full implementation, you'd calculate actual confidence
+            confidence = 0.95  # Placeholder
+            
+            return {
+                'text': text,
+                'confidence': confidence
+            }
+        except Exception as e:
+            self.logger.error(f"Error in prediction: {e}")
+            return {
+                'text': "",
+                'confidence': 0.0
+            }
+    
+    def batch_predict_with_confidence(self, images: List[Union[str, Image.Image]]) -> List[Dict[str, Union[str, float]]]:
+        """
+        Predict text with confidence for multiple images
+        
+        Args:
+            images: List of image paths or PIL Image objects
+            
+        Returns:
+            List of dictionaries with 'text' and 'confidence' keys
+        """
+        results = []
+        for image in images:
+            result = self.predict_with_confidence(image)
+            results.append(result)
+        
+        return results
+    
+    def process_document(self, image_path: str, output_path: Optional[str] = None) -> Dict[str, str]:
+        """
+        Process a document image and save results
+        
+        Args:
+            image_path: Path to document image
+            output_path: Path to save results (optional)
+            
+        Returns:
+            Dictionary with processing results
+        """
+        try:
+            # Load and process image
+            image = Image.open(image_path)
+            text = self.ocr.predict(image)
+            
+            results = {
+                'image_path': image_path,
+                'extracted_text': text,
+                'status': 'success'
+            }
+            
+            # Save results if output path provided
+            if output_path:
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    json.dump(results, f, ensure_ascii=False, indent=2)
+            
+            return results
+            
+        except Exception as e:
+            error_result = {
+                'image_path': image_path,
+                'extracted_text': "",
+                'status': 'error',
+                'error': str(e)
+            }
+            
+            if output_path:
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    json.dump(error_result, f, ensure_ascii=False, indent=2)
+            
+            return error_result

monocr-0.1.0/src/monocr/ocr.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Main Mon OCR class - Production-ready OCR for Mon text
+Supports both CRNN and TrOCR models
+"""
+
+import os
+import torch
+import torch.nn as nn
+import numpy as np
+from PIL import Image
+from pathlib import Path
+import json
+import logging
+from typing import List, Dict, Optional, Union
+from torchvision import transforms
+
+# TrOCR imports (optional)
+try:
+    from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+    TROCR_AVAILABLE = True
+except ImportError:
+    TROCR_AVAILABLE = False
+
+class MonOCR:
+    """Production-ready Mon OCR class supporting both CRNN and TrOCR models"""
+    
+    def __init__(self, model_path: Optional[str] = None, model_type: str = "crnn"):
+        """
+        Initialize Mon OCR
+        
+        Args:
+            model_path: Path to trained model file (if None, uses bundled model)
+            model_type: Type of model ("crnn" or "trocr")
+        """
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model_type = model_type.lower()
+        self.model = None
+        self.processor = None
+        self.charset = None
+        
+        # Load model - use bundled model if no path provided
+        if model_path is None:
+            from . import get_default_model_path
+            model_path = get_default_model_path()
+        
+        self.load_model(model_path)
+    
+    def load_model(self, model_path: str):
+        """Load trained model from file"""
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model file not found: {model_path}")
+        
+        if self.model_type == "crnn":
+            self._load_crnn_model(model_path)
+        elif self.model_type == "trocr":
+            self._load_trocr_model(model_path)
+        else:
+            raise ValueError(f"Unsupported model type: {self.model_type}")
+    
+    def _load_crnn_model(self, model_path: str):
+        """Load CRNN model"""
+        # Import CRNN model class (this would need to be included in the package)
+        from .crnn_model import CRNN, build_charset
+        
+        # Load model state
+        checkpoint = torch.load(model_path, map_location=self.device)
+        
+        # Extract charset from checkpoint or build from corpus
+        if 'charset' in checkpoint:
+            self.charset = checkpoint['charset']
+        else:
+            # Fallback: build charset from default corpus
+            self.charset = build_charset("data/raw/corpus")
+        
+        # Initialize model (add 1 for blank token)
+        self.model = CRNN(num_classes=len(self.charset) + 1)
+        
+        # Load weights
+        if 'model_state_dict' in checkpoint:
+            self.model.load_state_dict(checkpoint['model_state_dict'])
+        else:
+            self.model.load_state_dict(checkpoint)
+        
+        self.model.to(self.device)
+        self.model.eval()
+    
+    def _load_trocr_model(self, model_path: str):
+        """Load TrOCR model"""
+        if not TROCR_AVAILABLE:
+            raise ImportError("TrOCR dependencies not available. Install with: pip install transformers")
+        
+        self.model = VisionEncoderDecoderModel.from_pretrained(model_path)
+        self.processor = TrOCRProcessor.from_pretrained(model_path)
+        self.model.to(self.device)
+        self.model.eval()
+    
+    def predict(self, image: Union[str, Image.Image]) -> str:
+        """
+        Predict text from image
+        
+        Args:
+            image: Path to image file or PIL Image object
+            
+        Returns:
+            Predicted text string
+        """
+        if isinstance(image, str):
+            image = Image.open(image).convert("L")
+        elif not isinstance(image, Image.Image):
+            raise ValueError("Image must be a file path or PIL Image")
+        
+        if self.model_type == "crnn":
+            return self._predict_crnn(image)
+        elif self.model_type == "trocr":
+            return self._predict_trocr(image)
+    
+    def _predict_crnn(self, image: Image.Image) -> str:
+        """Predict using CRNN model"""
+        if self.model is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+        
+        # Preprocess image - match simple_inference.py exactly
+        if isinstance(image, str):
+            image = Image.open(image).convert('L')
+        elif isinstance(image, Image.Image):
+            image = image.convert('L')
+        
+        # Resize image - target_size is (height, width) for the model
+        # PIL resize expects (width, height), so we need to swap
+        image = image.resize((256, 64), Image.Resampling.LANCZOS)
+        
+        # Convert to tensor and normalize
+        image_array = np.array(image, dtype=np.float32) / 255.0
+        image_tensor = torch.from_numpy(image_array).unsqueeze(0).unsqueeze(0)  # [1, 1, H, W]
+        
+        # Apply the same transform as training
+        transform = transforms.Compose([
+            transforms.Normalize(mean=[0.5], std=[0.5])
+        ])
+        image_tensor = transform(image_tensor)
+        image_tensor = image_tensor.to(self.device)
+        
+        # Predict
+        with torch.no_grad():
+            outputs = self.model(image_tensor)
+            predicted_text = self._decode_crnn_output(outputs)
+        
+        return predicted_text
+    
+    def _predict_trocr(self, image: Image.Image) -> str:
+        """Predict using TrOCR model"""
+        if self.model is None or self.processor is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+        
+        # Preprocess image
+        pixel_values = self.processor(image, return_tensors="pt").pixel_values.to(self.device)
+        
+        # Predict
+        with torch.no_grad():
+            generated_ids = self.model.generate(pixel_values)
+            predicted_text = self.processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        
+        return predicted_text
+    
+    def _decode_crnn_output(self, output: torch.Tensor) -> str:
+        """Decode CRNN output to text - match simple_inference.py exactly"""
+        if self.charset is None:
+            raise ValueError("Charset not loaded")
+        
+        # Get predictions - same as working version
+        preds = output.softmax(2).argmax(2).squeeze(0)  # [seq_len]
+        
+        # CTC decoding - exact same logic as working simple_inference.py
+        decoded = []
+        prev_char = None
+        
+        for idx in preds:
+            idx = idx.item()
+            if idx == 0:  # blank token
+                prev_char = None
+            elif idx != prev_char:  # new character
+                if idx <= len(self.charset):  # idx is 1-based, charset is 0-based
+                    decoded.append(self.charset[idx - 1])
+                prev_char = idx
+        
+        return ''.join(decoded)
+    
+    def batch_predict(self, images: List[Union[str, Image.Image]]) -> List[str]:
+        """
+        Predict text from multiple images
+        
+        Args:
+            images: List of image paths or PIL Image objects
+            
+        Returns:
+            List of predicted text strings
+        """
+        results = []
+        for image in images:
+            try:
+                result = self.predict(image)
+                results.append(result)
+            except Exception as e:
+                logging.warning(f"Error processing image: {e}")
+                results.append("")
+        
+        return results
+    
+    def read_text(self, image: Union[str, Image.Image]) -> str:
+        """
+        Read text from image (alias for predict method)
+        
+        Args:
+            image: Path to image file or PIL Image object
+            
+        Returns:
+            Extracted text string
+        """
+        return self.predict(image)
+    
+    def read_multiple(self, images: List[Union[str, Image.Image]]) -> List[str]:
+        """
+        Read text from multiple images (alias for batch_predict method)
+        
+        Args:
+            images: List of image paths or PIL Image objects
+            
+        Returns:
+            List of extracted text strings
+        """
+        return self.batch_predict(images)
+    
+    def read_from_folder(self, folder_path: str, extensions: List[str] = None) -> dict:
+        """
+        Read text from all images in a folder
+        
+        Args:
+            folder_path: Path to folder containing images
+            extensions: List of file extensions to process (default: ['.png', '.jpg', '.jpeg'])
+            
+        Returns:
+            Dictionary mapping filename to extracted text
+        """
+        if extensions is None:
+            extensions = ['.png', '.jpg', '.jpeg', '.bmp', '.tiff']
+        
+        folder = Path(folder_path)
+        if not folder.exists():
+            raise FileNotFoundError(f"Folder not found: {folder_path}")
+        
+        results = {}
+        image_files = []
+        
+        for ext in extensions:
+            image_files.extend(folder.glob(f"*{ext}"))
+            image_files.extend(folder.glob(f"*{ext.upper()}"))
+        
+        for image_file in image_files:
+            try:
+                text = self.read_text(str(image_file))
+                results[image_file.name] = text
+            except Exception as e:
+                print(f"Error processing {image_file.name}: {e}")
+                results[image_file.name] = ""
+        
+        return results