// TesseractOCR: no way to tell failure from "no text on this page"
using var engine = new Engine(@"./tessdata", Language.English);
using var img = Pix.Image.LoadFromFile(imagePath);
using var page = engine.Process(img);

var text = page.Text; // returns "" on engine failure — same as blank page
// Caller cannot distinguish OCR failure from legitimate empty result

// TesseractOCR: no way to tell failure from "no text on this page"
using var engine = new Engine(@"./tessdata", Language.English);
using var img = Pix.Image.LoadFromFile(imagePath);
using var page = engine.Process(img);

var text = page.Text; // returns "" on engine failure — same as blank page
// Caller cannot distinguish OCR failure from legitimate empty result

// IronOCR: failures throw, low-confidence results are detectable
var result = new IronTesseract().Read(imagePath);
// result.Confidence is 0-100; a score below 10 signals a processing problem
// An engine failure throws IronOcrException — never returns a silent empty string
Console.WriteLine($"Text: {result.Text}, Confidence: {result.Confidence}%");

// IronOCR: failures throw, low-confidence results are detectable
var result = new IronTesseract().Read(imagePath);
// result.Confidence is 0-100; a score below 10 signals a processing problem
// An engine failure throws IronOcrException — never returns a silent empty string
Console.WriteLine($"Text: {result.Text}, Confidence: {result.Confidence}%");

dotnet remove package TesseractOCR

dotnet remove package TesseractOCR

// Before (Tesseract OCR Wrapper)
using TesseractOCR;
using TesseractOCR.Enums;

// After (IronOCR)
using IronOcr;

// Before (Tesseract OCR Wrapper)
using TesseractOCR;
using TesseractOCR.Enums;

// After (IronOCR)
using IronOcr;

using TesseractOCR;

public class DocumentProcessor
{
    private readonly string _tessDataPath = @"./tessdata";

    public string ProcessDocument(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        // Empty string on engine failure — indistinguishable from blank page
        // Non exception thrown, no confidence signal, no recovery path
        var text = page.Text;

        // Caller cannot tell if this is "" because:
        // - The document is genuinely blank
        // - The image format was not supported
        // - The engine encountered an internal error
        // - The tessdata was corrupted or version-mismatched
        return text;
    }
}

using TesseractOCR;

public class DocumentProcessor
{
    private readonly string _tessDataPath = @"./tessdata";

    public string ProcessDocument(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        // Empty string on engine failure — indistinguishable from blank page
        // Non exception thrown, no confidence signal, no recovery path
        var text = page.Text;

        // Caller cannot tell if this is "" because:
        // - The document is genuinely blank
        // - The image format was not supported
        // - The engine encountered an internal error
        // - The tessdata was corrupted or version-mismatched
        return text;
    }
}

using IronOcr;

public class DocumentProcessor
{
    public string ProcessDocument(string imagePath)
    {
        try
        {
            var result = new IronTesseract().Read(imagePath);

            // Confidence below threshold means the result is unreliable
            if (result.Confidence < 15)
            {
                // Route to human review queue — do not silently write empty data
                throw new InvalidOperationException(
                    $"OCR confidence too low ({result.Confidence:F1}%) for: {imagePath}");
            }

            return result.Text;
        }
        catch (IronOcrException ex)
        {
            // Engine failures are typed exceptions — never silent empty strings
            // Log and rethrow with context so the pipeline can flag the document
            throw new ApplicationException(
                $"OCR engine failure processing '{imagePath}': {ex.Message}", ex);
        }
    }
}

using IronOcr;

public class DocumentProcessor
{
    public string ProcessDocument(string imagePath)
    {
        try
        {
            var result = new IronTesseract().Read(imagePath);

            // Confidence below threshold means the result is unreliable
            if (result.Confidence < 15)
            {
                // Route to human review queue — do not silently write empty data
                throw new InvalidOperationException(
                    $"OCR confidence too low ({result.Confidence:F1}%) for: {imagePath}");
            }

            return result.Text;
        }
        catch (IronOcrException ex)
        {
            // Engine failures are typed exceptions — never silent empty strings
            // Log and rethrow with context so the pipeline can flag the document
            throw new ApplicationException(
                $"OCR engine failure processing '{imagePath}': {ex.Message}", ex);
        }
    }
}

using TesseractOCR;
// Also requires: a PDF library (PDFsharp, iText, or similar)
// Also requires: a PDF rasterizer (PdfiumViewer or Ghostscript) to convert input PDFs to images

public class ArchivePipeline
{
    private readonly string _tessDataPath = @"./tessdata";

    public string ExtractText(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        return page.Text; // Plain text only — searchable PDF requires a separate pipeline
    }

    // To create a searchable PDF from this text, you would need:
    // 1. Load the original image as a PDF page background
    // 2. Map character positions back to image coordinates
    // 3. Overlay an invisible text layer using a PDF library
    // 4. Handle multi-page documents with per-page iteration
    // That is approximately 150-300 lines of additional code
}

using TesseractOCR;
// Also requires: a PDF library (PDFsharp, iText, or similar)
// Also requires: a PDF rasterizer (PdfiumViewer or Ghostscript) to convert input PDFs to images

public class ArchivePipeline
{
    private readonly string _tessDataPath = @"./tessdata";

    public string ExtractText(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        return page.Text; // Plain text only — searchable PDF requires a separate pipeline
    }

    // To create a searchable PDF from this text, you would need:
    // 1. Load the original image as a PDF page background
    // 2. Map character positions back to image coordinates
    // 3. Overlay an invisible text layer using a PDF library
    // 4. Handle multi-page documents with per-page iteration
    // That is approximately 150-300 lines of additional code
}

using IronOcr;

public class ArchivePipeline
{
    // Single method handles the full document archive pipeline
    public void ProcessArchive(string[] inputPaths, string outputDirectory)
    {
        var ocr = new IronTesseract();

        foreach (var inputPath in inputPaths)
        {
            var result = ocr.Read(inputPath);

            // Plain text for full-text search indexing
            var textPath = Path.Combine(outputDirectory,
                Path.GetFileNameWithoutExtension(inputPath) + ".txt");
            File.WriteAllText(textPath, result.Text);

            // Searchable PDF — invisible text layer aligned to original scan
            var pdfPath = Path.Combine(outputDirectory,
                Path.GetFileNameWithoutExtension(inputPath) + "-searchable.pdf");
            result.SaveAsSearchablePdf(pdfPath);
        }
    }

    // Input can be scanned image files or existing PDFs — same API
    public void ProcessScannedPdf(string scannedPdfPath, string outputPath)
    {
        var result = new IronTesseract().Read(scannedPdfPath);
        result.SaveAsSearchablePdf(outputPath);
    }
}

using IronOcr;

public class ArchivePipeline
{
    // Single method handles the full document archive pipeline
    public void ProcessArchive(string[] inputPaths, string outputDirectory)
    {
        var ocr = new IronTesseract();

        foreach (var inputPath in inputPaths)
        {
            var result = ocr.Read(inputPath);

            // Plain text for full-text search indexing
            var textPath = Path.Combine(outputDirectory,
                Path.GetFileNameWithoutExtension(inputPath) + ".txt");
            File.WriteAllText(textPath, result.Text);

            // Searchable PDF — invisible text layer aligned to original scan
            var pdfPath = Path.Combine(outputDirectory,
                Path.GetFileNameWithoutExtension(inputPath) + "-searchable.pdf");
            result.SaveAsSearchablePdf(pdfPath);
        }
    }

    // Input can be scanned image files or existing PDFs — same API
    public void ProcessScannedPdf(string scannedPdfPath, string outputPath)
    {
        var result = new IronTesseract().Read(scannedPdfPath);
        result.SaveAsSearchablePdf(outputPath);
    }
}

using TesseractOCR;

public class BatchOcrService
{
    // tessdata path must be configured correctly in every environment
    private readonly string _tessDataPath;

    public BatchOcrService(string tessDataPath)
    {
        // Path validation deferred to runtime — no early error on misconfiguration
        _tessDataPath = tessDataPath;
    }

    public IEnumerable<string> ProcessBatch(IEnumerable<string> imagePaths)
    {
        var results = new List<string>();

        foreach (var path in imagePaths)
        {
            // New engine created per document — tessdata path re-resolved each time
            using var engine = new Engine(_tessDataPath, Language.English);
            using var img = Pix.Image.LoadFromFile(path);
            using var page = engine.Process(img);

            results.Add(page.Text);
        }

        return results;
    }
}

using TesseractOCR;

public class BatchOcrService
{
    // tessdata path must be configured correctly in every environment
    private readonly string _tessDataPath;

    public BatchOcrService(string tessDataPath)
    {
        // Path validation deferred to runtime — no early error on misconfiguration
        _tessDataPath = tessDataPath;
    }

    public IEnumerable<string> ProcessBatch(IEnumerable<string> imagePaths)
    {
        var results = new List<string>();

        foreach (var path in imagePaths)
        {
            // New engine created per document — tessdata path re-resolved each time
            using var engine = new Engine(_tessDataPath, Language.English);
            using var img = Pix.Image.LoadFromFile(path);
            using var page = engine.Process(img);

            results.Add(page.Text);
        }

        return results;
    }
}

using IronOcr;

public class BatchOcrService
{
    // One IronTesseract instance for the lifetime of the service
    // Thread-safe — can be registered as a singleton in DI
    private readonly IronTesseract _ocr;

    public BatchOcrService()
    {
        _ocr = new IronTesseract();
        // Optional: tune for batch throughput
        _ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
    }

    public IEnumerable<string> ProcessBatch(IEnumerable<string> imagePaths)
    {
        // Reuse the initialized engine — no tessdata path re-resolution per call
        return imagePaths.Select(path => _ocr.Read(path).Text).ToList();
    }

    // Parallel batch processing — IronTesseract is thread-safe with separate instances
    public IEnumerable<string> ProcessBatchParallel(string[] imagePaths)
    {
        var results = new string[imagePaths.Length];

        Parallel.For(0, imagePaths.Length, i =>
        {
            // Separate instance per thread — thread-safe by design
            var ocr = new IronTesseract();
            results[i] = ocr.Read(imagePaths[i]).Text;
        });

        return results;
    }
}

using IronOcr;

public class BatchOcrService
{
    // One IronTesseract instance for the lifetime of the service
    // Thread-safe — can be registered as a singleton in DI
    private readonly IronTesseract _ocr;

    public BatchOcrService()
    {
        _ocr = new IronTesseract();
        // Optional: tune for batch throughput
        _ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
    }

    public IEnumerable<string> ProcessBatch(IEnumerable<string> imagePaths)
    {
        // Reuse the initialized engine — no tessdata path re-resolution per call
        return imagePaths.Select(path => _ocr.Read(path).Text).ToList();
    }

    // Parallel batch processing — IronTesseract is thread-safe with separate instances
    public IEnumerable<string> ProcessBatchParallel(string[] imagePaths)
    {
        var results = new string[imagePaths.Length];

        Parallel.For(0, imagePaths.Length, i =>
        {
            // Separate instance per thread — thread-safe by design
            var ocr = new IronTesseract();
            results[i] = ocr.Read(imagePaths[i]).Text;
        });

        return results;
    }
}

using TesseractOCR;

public class UploadOcrController
{
    private readonly string _tessDataPath = @"./tessdata";

    public async Task<string> ProcessUpload(Stream uploadStream)
    {
        // Must write to temp file — no direct stream input path in the wrapper
        var tempPath = Path.GetTempFileName();
        try
        {
            using (var fileStream = File.Create(tempPath))
            {
                await uploadStream.CopyToAsync(fileStream);
            }

            using var engine = new Engine(_tessDataPath, Language.English);
            using var img = Pix.Image.LoadFromFile(tempPath); // file path required
            using var page = engine.Process(img);

            return page.Text;
        }
        finally
        {
            // Cleanup — if this throws, temp file leaks
            if (File.Exists(tempPath))
                File.Delete(tempPath);
        }
    }
}

using TesseractOCR;

public class UploadOcrController
{
    private readonly string _tessDataPath = @"./tessdata";

    public async Task<string> ProcessUpload(Stream uploadStream)
    {
        // Must write to temp file — no direct stream input path in the wrapper
        var tempPath = Path.GetTempFileName();
        try
        {
            using (var fileStream = File.Create(tempPath))
            {
                await uploadStream.CopyToAsync(fileStream);
            }

            using var engine = new Engine(_tessDataPath, Language.English);
            using var img = Pix.Image.LoadFromFile(tempPath); // file path required
            using var page = engine.Process(img);

            return page.Text;
        }
        finally
        {
            // Cleanup — if this throws, temp file leaks
            if (File.Exists(tempPath))
                File.Delete(tempPath);
        }
    }
}

using IronOcr;

public class UploadOcrController
{
    public string ProcessUpload(Stream uploadStream)
    {
        // Direct stream input — no temporary file, no I/O overhead, no cleanup
        using var input = new OcrInput();
        input.LoadImage(uploadStream);
        return new IronTesseract().Read(input).Text;
    }

    public string ProcessUploadBytes(byte[] imageBytes)
    {
        // Byte array input — works directly from memory
        using var input = new OcrInput();
        input.LoadImage(imageBytes);
        return new IronTesseract().Read(input).Text;
    }

    public string ProcessMultiPageTiff(Stream tiffStream)
    {
        // Multi-frame TIFF — all frames processed in one call
        using var input = new OcrInput();
        input.LoadImageFrames(tiffStream);
        return new IronTesseract().Read(input).Text;
    }
}

using IronOcr;

public class UploadOcrController
{
    public string ProcessUpload(Stream uploadStream)
    {
        // Direct stream input — no temporary file, no I/O overhead, no cleanup
        using var input = new OcrInput();
        input.LoadImage(uploadStream);
        return new IronTesseract().Read(input).Text;
    }

    public string ProcessUploadBytes(byte[] imageBytes)
    {
        // Byte array input — works directly from memory
        using var input = new OcrInput();
        input.LoadImage(imageBytes);
        return new IronTesseract().Read(input).Text;
    }

    public string ProcessMultiPageTiff(Stream tiffStream)
    {
        // Multi-frame TIFF — all frames processed in one call
        using var input = new OcrInput();
        input.LoadImageFrames(tiffStream);
        return new IronTesseract().Read(input).Text;
    }
}

using TesseractOCR;
using System.Text.RegularExpressions;

public class InvoiceFieldExtractor
{
    private readonly string _tessDataPath = @"./tessdata";

    public Dictionary<string, string> ExtractFields(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        var fullText = page.Text;

        // Must parse the full string — no spatial context available
        // Pattern matching is fragile across different invoice layouts
        var fields = new Dictionary<string, string>();

        var totalMatch = Regex.Match(fullText, @"Total[:\s]+\$?([\d,]+\.\d{2})");
        if (totalMatch.Success)
            fields["Total"] = totalMatch.Groups[1].Value;

        var dateMatch = Regex.Match(fullText, @"Date[:\s]+(\d{1,2}/\d{1,2}/\d{4})");
        if (dateMatch.Success)
            fields["Date"] = dateMatch.Groups[1].Value;

        return fields;
        // Non spatial fallback when text patterns fail — the data is lost
    }
}

using TesseractOCR;
using System.Text.RegularExpressions;

public class InvoiceFieldExtractor
{
    private readonly string _tessDataPath = @"./tessdata";

    public Dictionary<string, string> ExtractFields(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        var fullText = page.Text;

        // Must parse the full string — no spatial context available
        // Pattern matching is fragile across different invoice layouts
        var fields = new Dictionary<string, string>();

        var totalMatch = Regex.Match(fullText, @"Total[:\s]+\$?([\d,]+\.\d{2})");
        if (totalMatch.Success)
            fields["Total"] = totalMatch.Groups[1].Value;

        var dateMatch = Regex.Match(fullText, @"Date[:\s]+(\d{1,2}/\d{1,2}/\d{4})");
        if (dateMatch.Success)
            fields["Date"] = dateMatch.Groups[1].Value;

        return fields;
        // Non spatial fallback when text patterns fail — the data is lost
    }
}

using IronOcr;

public class InvoiceFieldExtractor
{
    public Dictionary<string, string> ExtractFields(string imagePath)
    {
        var result = new IronTesseract().Read(imagePath);
        var fields = new Dictionary<string, string>();

        // Traverse structured result — words carry position and confidence
        foreach (var page in result.Pages)
        {
            foreach (var paragraph in page.Paragraphs)
            {
                var paraText = paragraph.Text.Trim();

                // Spatial proximity: find words near known label positions
                if (paraText.StartsWith("Total", StringComparison.OrdinalIgnoreCase))
                {
                    fields["Total"] = paraText;
                    // paragraph.X, paragraph.Y give position for layout validation
                }

                if (paraText.StartsWith("Invoice Date", StringComparison.OrdinalIgnoreCase))
                {
                    fields["Date"] = paraText;
                }
            }
        }

        // Flag low-confidence extractions for review rather than silently accepting them
        var lowConfidenceWords = result.Pages
            .SelectMany(p => p.Paragraphs)
            .SelectMany(para => para.Words)
            .Where(w => w.Confidence < 50)
            .Select(w => w.Text)
            .ToList();

        if (lowConfidenceWords.Any())
            fields["_LowConfidenceWarning"] = string.Join(", ", lowConfidenceWords);

        return fields;
    }
}

using IronOcr;

public class InvoiceFieldExtractor
{
    public Dictionary<string, string> ExtractFields(string imagePath)
    {
        var result = new IronTesseract().Read(imagePath);
        var fields = new Dictionary<string, string>();

        // Traverse structured result — words carry position and confidence
        foreach (var page in result.Pages)
        {
            foreach (var paragraph in page.Paragraphs)
            {
                var paraText = paragraph.Text.Trim();

                // Spatial proximity: find words near known label positions
                if (paraText.StartsWith("Total", StringComparison.OrdinalIgnoreCase))
                {
                    fields["Total"] = paraText;
                    // paragraph.X, paragraph.Y give position for layout validation
                }

                if (paraText.StartsWith("Invoice Date", StringComparison.OrdinalIgnoreCase))
                {
                    fields["Date"] = paraText;
                }
            }
        }

        // Flag low-confidence extractions for review rather than silently accepting them
        var lowConfidenceWords = result.Pages
            .SelectMany(p => p.Paragraphs)
            .SelectMany(para => para.Words)
            .Where(w => w.Confidence < 50)
            .Select(w => w.Text)
            .ToList();

        if (lowConfidenceWords.Any())
            fields["_LowConfidenceWarning"] = string.Join(", ", lowConfidenceWords);

        return fields;
    }
}

try
{
    var result = new IronTesseract().Read(imagePath);
    if (result.Confidence < 10)
    {
        // Genuinely unreadable or blank — route to review
        return string.Empty;
    }
    return result.Text;
}
catch (IronOcrException)
{
    // Engine failure — log and handle separately from blank pages
    return null; // or rethrow
}

try
{
    var result = new IronTesseract().Read(imagePath);
    if (result.Confidence < 10)
    {
        // Genuinely unreadable or blank — route to review
        return string.Empty;
    }
    return result.Text;
}
catch (IronOcrException)
{
    // Engine failure — log and handle separately from blank pages
    return null; // or rethrow
}

// Before (TesseractOCR): if (confidence < 0.7f)
// After (IronOCR):
if (result.Confidence < 70)
{
    // Below 70% confidence
}

// Before (TesseractOCR): if (confidence < 0.7f)
// After (IronOCR):
if (result.Confidence < 70)
{
    // Below 70% confidence
}

// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.German

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;
ocr.AddSecondaryLanguage(OcrLanguage.French);
ocr.AddSecondaryLanguage(OcrLanguage.German);

// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.German

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;
ocr.AddSecondaryLanguage(OcrLanguage.French);
ocr.AddSecondaryLanguage(OcrLanguage.German);

// Before: new Engine(configuration["TessDataPath"], Language.English)
// After:
var ocr = new IronTesseract(); // language resolved from NuGet package
ocr.Language = OcrLanguage.English;

// Before: new Engine(configuration["TessDataPath"], Language.English)
// After:
var ocr = new IronTesseract(); // language resolved from NuGet package
ocr.Language = OcrLanguage.English;

// Before: rasterize each PDF page to bitmap, OCR each bitmap, collect results
// After:
using var input = new OcrInput();
input.LoadPdf("document.pdf");
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

// Before: rasterize each PDF page to bitmap, OCR each bitmap, collect results
// After:
using var input = new OcrInput();
input.LoadPdf("document.pdf");
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

// Before: write to temp, OCR, delete temp
// After:
public async Task<string> OcrUpload(IFormFile file)
{
    using var stream = file.OpenReadStream();
    using var input = new OcrInput();
    input.LoadImage(stream);
    return new IronTesseract().Read(input).Text;
}

// Before: write to temp, OCR, delete temp
// After:
public async Task<string> OcrUpload(IFormFile file)
{
    using var stream = file.OpenReadStream();
    using var input = new OcrInput();
    input.LoadImage(stream);
    return new IronTesseract().Read(input).Text;
}

# Find all files using the TesseractOCR namespace
grep -r "using TesseractOCR" --include="*.cs" .

# Find Engine constructor calls — these carry the tessdata path
grep -rn "new Engine(" --include="*.cs" .

# Find tessdata path configuration references
grep -rn "tessdata" --include="*.cs" .
grep -rn "tessdata" --include="*.json" .
grep -rn "tessdata" --include="*.xml" .

# Find all page.Text and page.GetText() calls — the primary output pattern
grep -rn "page\.Text\|page\.GetText()" --include="*.cs" .

# Find GetMeanConfidence calls — confidence scale will change
grep -rn "GetMeanConfidence" --include="*.cs" .

# Find PDF rasterization libraries that can be removed after migration
grep -rn "PdfiumViewer\|Ghostscript\|PDFsharp" --include="*.cs" .
grep -rn "PdfiumViewer\|Ghostscript\|PdfSharp" --include="*.csproj" .

# Find all files using the TesseractOCR namespace
grep -r "using TesseractOCR" --include="*.cs" .

# Find Engine constructor calls — these carry the tessdata path
grep -rn "new Engine(" --include="*.cs" .

# Find tessdata path configuration references
grep -rn "tessdata" --include="*.cs" .
grep -rn "tessdata" --include="*.json" .
grep -rn "tessdata" --include="*.xml" .

# Find all page.Text and page.GetText() calls — the primary output pattern
grep -rn "page\.Text\|page\.GetText()" --include="*.cs" .

# Find GetMeanConfidence calls — confidence scale will change
grep -rn "GetMeanConfidence" --include="*.cs" .

# Find PDF rasterization libraries that can be removed after migration
grep -rn "PdfiumViewer\|Ghostscript\|PDFsharp" --include="*.cs" .
grep -rn "PdfiumViewer\|Ghostscript\|PdfSharp" --include="*.csproj" .