Migrating from Tesseract OCR Wrapper to IronOCR

// 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

Imports Tesseract

' TesseractOCR: no way to tell failure from "no text on this page"
Using engine As New Engine("./tessdata", Language.English)
    Using img As Pix.Image = Pix.Image.LoadFromFile(imagePath)
        Using page As Page = engine.Process(img)
            Dim text As String = page.Text ' returns "" on engine failure — same as blank page
            ' Caller cannot distinguish OCR failure from legitimate empty result
        End Using
    End Using
End Using

// 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}%");

Imports IronOcr

' IronOCR: failures throw, low-confidence results are detectable
Dim 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

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

// After (IronOCR)
using IronOcr;

Imports IronOcr

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

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
        // No 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;
    }
}

Imports TesseractOCR

Public Class DocumentProcessor
    Private ReadOnly _tessDataPath As String = "./tessdata"

    Public Function ProcessDocument(imagePath As String) As String
        Using engine = New Engine(_tessDataPath, Language.English)
            Using img = Pix.Image.LoadFromFile(imagePath)
                Using page = engine.Process(img)

                    ' Empty string on engine failure — indistinguishable from blank page
                    ' No exception thrown, no confidence signal, no recovery path
                    Dim 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
                End Using
            End Using
        End Using
    End Function
End Class

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);
        }
    }
}

Imports IronOcr

Public Class DocumentProcessor
    Public Function ProcessDocument(imagePath As String) As String
        Try
            Dim result = New IronTesseract().Read(imagePath)

            ' Confidence below threshold means the result is unreliable
            If result.Confidence < 15 Then
                ' Route to human review queue — do not silently write empty data
                Throw New InvalidOperationException(
                    $"OCR confidence too low ({result.Confidence:F1}%) for: {imagePath}")
            End If

            Return result.Text
        Catch ex As IronOcrException
            ' 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)
        End Try
    End Function
End Class

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
}

Imports 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 _tessDataPath As String = "./tessdata"

    Public Function ExtractText(imagePath As String) As String
        Using engine = New Engine(_tessDataPath, Language.English)
            Using img = Pix.Image.LoadFromFile(imagePath)
                Using page = engine.Process(img)
                    Return page.Text ' Plain text only — searchable PDF requires a separate pipeline
                End Using
            End Using
        End Using
    End Function

    ' 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
End Class

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);
    }
}

Imports IronOcr

Public Class ArchivePipeline
    ' Single method handles the full document archive pipeline
    Public Sub ProcessArchive(inputPaths As String(), outputDirectory As String)
        Dim ocr As New IronTesseract()

        For Each inputPath In inputPaths
            Dim result = ocr.Read(inputPath)

            ' Plain text for full-text search indexing
            Dim textPath = Path.Combine(outputDirectory, Path.GetFileNameWithoutExtension(inputPath) & ".txt")
            File.WriteAllText(textPath, result.Text)

            ' Searchable PDF — invisible text layer aligned to original scan
            Dim pdfPath = Path.Combine(outputDirectory, Path.GetFileNameWithoutExtension(inputPath) & "-searchable.pdf")
            result.SaveAsSearchablePdf(pdfPath)
        Next
    End Sub

    ' Input can be scanned image files or existing PDFs — same API
    Public Sub ProcessScannedPdf(scannedPdfPath As String, outputPath As String)
        Dim result = (New IronTesseract()).Read(scannedPdfPath)
        result.SaveAsSearchablePdf(outputPath)
    End Sub
End Class

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;
    }
}

Imports TesseractOCR

Public Class BatchOcrService
    ' tessdata path must be configured correctly in every environment
    Private ReadOnly _tessDataPath As String

    Public Sub New(tessDataPath As String)
        ' Path validation deferred to runtime — no early error on misconfiguration
        _tessDataPath = tessDataPath
    End Sub

    Public Function ProcessBatch(imagePaths As IEnumerable(Of String)) As IEnumerable(Of String)
        Dim results As New List(Of String)()

        For Each path In imagePaths
            ' New engine created per document — tessdata path re-resolved each time
            Using engine = New Engine(_tessDataPath, Language.English)
                Using img = Pix.Image.LoadFromFile(path)
                    Using page = engine.Process(img)
                        results.Add(page.Text)
                    End Using
                End Using
            End Using
        Next

        Return results
    End Function
End Class

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;
    }
}

Imports 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 _ocr As IronTesseract

    Public Sub New()
        _ocr = New IronTesseract()
        ' Optional: tune for batch throughput
        _ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5
    End Sub

    Public Function ProcessBatch(imagePaths As IEnumerable(Of String)) As IEnumerable(Of String)
        ' Reuse the initialized engine — no tessdata path re-resolution per call
        Return imagePaths.Select(Function(path) _ocr.Read(path).Text).ToList()
    End Function

    ' Parallel batch processing — IronTesseract is thread-safe with separate instances
    Public Function ProcessBatchParallel(imagePaths As String()) As IEnumerable(Of String)
        Dim results(imagePaths.Length - 1) As String

        Parallel.For(0, imagePaths.Length, Sub(i)
                                               ' Separate instance per thread — thread-safe by design
                                               Dim ocr = New IronTesseract()
                                               results(i) = ocr.Read(imagePaths(i)).Text
                                           End Sub)

        Return results
    End Function
End Class

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);
        }
    }
}

Imports TesseractOCR
Imports System.IO
Imports System.Threading.Tasks

Public Class UploadOcrController
    Private ReadOnly _tessDataPath As String = "./tessdata"

    Public Async Function ProcessUpload(uploadStream As Stream) As Task(Of String)
        ' Must write to temp file — no direct stream input path in the wrapper
        Dim tempPath As String = Path.GetTempFileName()
        Try
            Using fileStream As FileStream = File.Create(tempPath)
                Await uploadStream.CopyToAsync(fileStream)
            End Using

            Using engine As New Engine(_tessDataPath, Language.English)
                Using img As Pix.Image = Pix.Image.LoadFromFile(tempPath) ' file path required
                    Using page As Page = engine.Process(img)
                        Return page.Text
                    End Using
                End Using
            End Using
        Finally
            ' Cleanup — if this throws, temp file leaks
            If File.Exists(tempPath) Then
                File.Delete(tempPath)
            End If
        End Try
    End Function
End Class

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;
    }
}

Imports IronOcr

Public Class UploadOcrController
    Public Function ProcessUpload(uploadStream As Stream) As String
        ' Direct stream input — no temporary file, no I/O overhead, no cleanup
        Using input As New OcrInput()
            input.LoadImage(uploadStream)
            Return New IronTesseract().Read(input).Text
        End Using
    End Function

    Public Function ProcessUploadBytes(imageBytes As Byte()) As String
        ' Byte array input — works directly from memory
        Using input As New OcrInput()
            input.LoadImage(imageBytes)
            Return New IronTesseract().Read(input).Text
        End Using
    End Function

    Public Function ProcessMultiPageTiff(tiffStream As Stream) As String
        ' Multi-frame TIFF — all frames processed in one call
        Using input As New OcrInput()
            input.LoadImageFrames(tiffStream)
            Return New IronTesseract().Read(input).Text
        End Using
    End Function
End Class

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;
        // No spatial fallback when text patterns fail — the data is lost
    }
}

Imports TesseractOCR
Imports System.Text.RegularExpressions

Public Class InvoiceFieldExtractor
    Private ReadOnly _tessDataPath As String = "./tessdata"

    Public Function ExtractFields(imagePath As String) As Dictionary(Of String, String)
        Dim fields As New Dictionary(Of String, String)()

        Using engine As New Engine(_tessDataPath, Language.English)
            Using img = Pix.Image.LoadFromFile(imagePath)
                Using page = engine.Process(img)
                    Dim fullText = page.Text

                    ' Must parse the full string — no spatial context available
                    ' Pattern matching is fragile across different invoice layouts

                    Dim totalMatch = Regex.Match(fullText, "Total[:\s]+\$?([\d,]+\.\d{2})")
                    If totalMatch.Success Then
                        fields("Total") = totalMatch.Groups(1).Value
                    End If

                    Dim dateMatch = Regex.Match(fullText, "Date[:\s]+(\d{1,2}/\d{1,2}/\d{4})")
                    If dateMatch.Success Then
                        fields("Date") = dateMatch.Groups(1).Value
                    End If
                End Using
            End Using
        End Using

        Return fields
        ' No spatial fallback when text patterns fail — the data is lost
    End Function
End Class

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;
    }
}

Imports IronOcr

Public Class InvoiceFieldExtractor
    Public Function ExtractFields(imagePath As String) As Dictionary(Of String, String)
        Dim result = New IronTesseract().Read(imagePath)
        Dim fields = New Dictionary(Of String, String)()

        ' Traverse structured result — words carry position and confidence
        For Each page In result.Pages
            For Each paragraph In page.Paragraphs
                Dim paraText = paragraph.Text.Trim()

                ' Spatial proximity: find words near known label positions
                If paraText.StartsWith("Total", StringComparison.OrdinalIgnoreCase) Then
                    fields("Total") = paraText
                    ' paragraph.X, paragraph.Y give position for layout validation
                End If

                If paraText.StartsWith("Invoice Date", StringComparison.OrdinalIgnoreCase) Then
                    fields("Date") = paraText
                End If
            Next
        Next

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

        If lowConfidenceWords.Any() Then
            fields("_LowConfidenceWarning") = String.Join(", ", lowConfidenceWords)
        End If

        Return fields
    End Function
End Class

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
}

Imports IronOcr

Try
    Dim result = New IronTesseract().Read(imagePath)
    If result.Confidence < 10 Then
        ' Genuinely unreadable or blank — route to review
        Return String.Empty
    End If
    Return result.Text
Catch ex As IronOcrException
    ' Engine failure — log and handle separately from blank pages
    Return Nothing ' or rethrow
End Try

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

' Before (TesseractOCR): If confidence < 0.7F Then
' After (IronOCR):
If result.Confidence < 70 Then
    ' Below 70% confidence
End If

// 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

Dim ocr As 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:
Dim ocr As 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);

Imports IronOcr

' Before: rasterize each PDF page to bitmap, OCR each bitmap, collect results
' After:
Using input As New OcrInput()
    input.LoadPdf("document.pdf")
    Dim result = New IronTesseract().Read(input)
    Console.WriteLine(result.Text)
End Using

// 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;
}

Imports System.Threading.Tasks

' Before: write to temp, OCR, delete temp
' After:
Public Async Function OcrUpload(file As IFormFile) As Task(Of String)
    Using stream = file.OpenReadStream()
        Using input = New OcrInput()
            input.LoadImage(stream)
            Return (New IronTesseract()).Read(input).Text
        End Using
    End Using
End Function

# 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" .