Migrating from TesseractOCR to IronOCR

// TesseractOCR: three packages, a temp file, and manual byte conversion
// just to OCR one PDF page — before any preprocessing
// dotnet add package TesseractOCR
// dotnet add package Docnet.Core
// dotnet add package SixLabors.ImageSharp   (preprocessing)

using var library = DocLib.Instance;
using var docReader = library.GetDocReader(pdfPath, new PageDimensions(200, 200));
using var pageReader = docReader.GetPageReader(0);
var bytes = pageReader.GetImage(); // BGRA — not a format Pix.Image accepts directly

string tempPath = Path.GetTempFileName() + ".png";
SaveBgraAsPng(bytes, pageReader.GetPageWidth(), pageReader.GetPageHeight(), tempPath);
// ^ 30+ line helper method needed here

using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
using var image = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
using var page = engine.Process(image);
string text = page.Text;
File.Delete(tempPath); // hope this succeeds

Imports Docnet.Core
Imports Docnet.Core.Models
Imports SixLabors.ImageSharp
Imports TesseractOCR

' TesseractOCR: three packages, a temp file, and manual byte conversion
' just to OCR one PDF page — before any preprocessing
' dotnet add package TesseractOCR
' dotnet add package Docnet.Core
' dotnet add package SixLabors.ImageSharp   (preprocessing)

Dim library = DocLib.Instance
Using library
    Dim docReader = library.GetDocReader(pdfPath, New PageDimensions(200, 200))
    Using docReader
        Dim pageReader = docReader.GetPageReader(0)
        Using pageReader
            Dim bytes = pageReader.GetImage() ' BGRA — not a format Pix.Image accepts directly

            Dim tempPath As String = Path.GetTempFileName() & ".png"
            SaveBgraAsPng(bytes, pageReader.GetPageWidth(), pageReader.GetPageHeight(), tempPath)
            ' ^ 30+ line helper method needed here

            Dim engine = New Engine("./tessdata", Language.English, EngineMode.Default)
            Using engine
                Dim image = TesseractOCR.Pix.Image.LoadFromFile(tempPath)
                Using image
                    Dim page = engine.Process(image)
                    Using page
                        Dim text As String = page.Text
                    End Using
                End Using
            End Using
            File.Delete(tempPath) ' hope this succeeds
        End Using
    End Using
End Using

// IronOCR: one package, three lines, preprocessing automatic
// dotnet add package IronOcr

var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadPdf(pdfPath);
string text = ocr.Read(input).Text;

Imports IronOcr

Dim ocr As New IronTesseract()
Using input As New OcrInput()
    input.LoadPdf(pdfPath)
    Dim text As String = ocr.Read(input).Text
End Using

dotnet remove package TesseractOCR
dotnet remove package Docnet.Core
dotnet remove package SixLabors.ImageSharp

// Before (TesseractOCR)
using TesseractOCR;
using TesseractOCR.Enums;

// After (IronOCR)
using IronOcr;

' Before (TesseractOCR)
Imports TesseractOCR
Imports TesseractOCR.Enums

' After (IronOCR)
Imports IronOcr

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

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

// Requires: dotnet add package SixLabors.ImageSharp
// Manual preprocessing — parameters must be tuned per document type
// Deskew is NOT in ImageSharp — requires custom Hough transform (~50-100 lines)

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using TesseractOCR;
using TesseractOCR.Enums;

public string ExtractFromLowQualityScan(string imagePath)
{
    using var image = Image.Load(imagePath);

    image.Mutate(x => x.Grayscale());
    image.Mutate(x => x.Contrast(1.5f));          // manual tuning required
    image.Mutate(x => x.GaussianBlur(0.5f));      // noise reduction approximation
    image.Mutate(x => x.BinaryThreshold(0.5f));   // threshold requires per-doc adjustment

    // Deskew omitted — no built-in support, ~80 lines of additional code

    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        image.Save(tempPath);

        using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
        using var pix = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
        using var page = engine.Process(pix);

        return page.Text;
    }
    finally
    {
        File.Delete(tempPath);
    }
}

Imports SixLabors.ImageSharp
Imports SixLabors.ImageSharp.Processing
Imports TesseractOCR
Imports TesseractOCR.Enums

Public Function ExtractFromLowQualityScan(imagePath As String) As String
    Using image As Image = Image.Load(imagePath)
        image.Mutate(Sub(x) x.Grayscale())
        image.Mutate(Sub(x) x.Contrast(1.5F))          ' manual tuning required
        image.Mutate(Sub(x) x.GaussianBlur(0.5F))      ' noise reduction approximation
        image.Mutate(Sub(x) x.BinaryThreshold(0.5F))   ' threshold requires per-doc adjustment

        ' Deskew omitted — no built-in support, ~80 lines of additional code

        Dim tempPath As String = Path.GetTempFileName() & ".png"
        Try
            image.Save(tempPath)

            Using engine As New Engine("./tessdata", Language.English, EngineMode.Default)
                Using pix As TesseractOCR.Pix.Image = TesseractOCR.Pix.Image.LoadFromFile(tempPath)
                    Using page As Page = engine.Process(pix)
                        Return page.Text
                    End Using
                End Using
            End Using
        Finally
            File.Delete(tempPath)
        End Try
    End Using
End Function

// No external imaging library
// No temp file — OcrInput accepts a path, stream, or byte array directly
// Deskew is built in — automatic angle detection and correction

using IronOcr;

public string ExtractFromLowQualityScan(string imagePath)
{
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    input.Deskew();           // automatic angle correction
    input.DeNoise();          // intelligent noise removal
    input.Contrast();         // automatic contrast enhancement
    input.Binarize();         // clean black-and-white conversion

    var ocr = new IronTesseract();
    return ocr.Read(input).Text;
}

Imports IronOcr

Public Function ExtractFromLowQualityScan(ByVal imagePath As String) As String
    Using input As New OcrInput()
        input.LoadImage(imagePath)
        input.Deskew()           ' automatic angle correction
        input.DeNoise()          ' intelligent noise removal
        input.Contrast()         ' automatic contrast enhancement
        input.Binarize()         ' clean black-and-white conversion

        Dim ocr As New IronTesseract()
        Return ocr.Read(input).Text
    End Using
End Function

// Requires: dotnet add package SixLabors.ImageSharp
// Manual frame extraction — every frame becomes a temp file on disk

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Tiff;
using TesseractOCR;
using TesseractOCR.Enums;

public string ExtractFromMultiPageTiff(string tiffPath)
{
    var allText = new System.Text.StringBuilder();
    var tempFiles = new List<string>();

    try
    {
        using var image = Image.Load(tiffPath);
        using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);

        for (int frameIndex = 0; frameIndex < image.Frames.Count; frameIndex++)
        {
            // Clone frame and save to temp file — no in-memory path
            using var frameImage = image.Frames.CloneFrame(frameIndex);
            string tempPath = Path.GetTempFileName() + ".png";
            tempFiles.Add(tempPath);
            frameImage.SaveAsPng(tempPath);

            using var pix = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
            using var page = engine.Process(pix);

            allText.AppendLine($"=== Frame {frameIndex + 1} ===");
            allText.AppendLine(page.Text);
        }
    }
    finally
    {
        foreach (var f in tempFiles)
            try { File.Delete(f); } catch { }
    }

    return allText.ToString();
}

Imports SixLabors.ImageSharp
Imports SixLabors.ImageSharp.Formats.Tiff
Imports TesseractOCR
Imports TesseractOCR.Enums
Imports System.Text

Public Function ExtractFromMultiPageTiff(tiffPath As String) As String
    Dim allText As New StringBuilder()
    Dim tempFiles As New List(Of String)()

    Try
        Using image = Image.Load(tiffPath)
            Using engine = New Engine("./tessdata", Language.English, EngineMode.Default)
                For frameIndex As Integer = 0 To image.Frames.Count - 1
                    ' Clone frame and save to temp file — no in-memory path
                    Using frameImage = image.Frames.CloneFrame(frameIndex)
                        Dim tempPath As String = Path.GetTempFileName() & ".png"
                        tempFiles.Add(tempPath)
                        frameImage.SaveAsPng(tempPath)

                        Using pix = TesseractOCR.Pix.Image.LoadFromFile(tempPath)
                            Using page = engine.Process(pix)
                                allText.AppendLine($"=== Frame {frameIndex + 1} ===")
                                allText.AppendLine(page.Text)
                            End Using
                        End Using
                    End Using
                Next
            End Using
        End Using
    Finally
        For Each f In tempFiles
            Try
                File.Delete(f)
            Catch
            End Try
        Next
    End Try

    Return allText.ToString()
End Function

// No external library for frame extraction
// All frames processed in one Read() call — no manual loop required

using IronOcr;

public string ExtractFromMultiPageTiff(string tiffPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImageFrames(tiffPath);   // loads all frames automatically
    var result = ocr.Read(input);

    // Access per-page text if needed
    foreach (var page in result.Pages)
        Console.WriteLine($"Frame {page.PageNumber}: {page.Text}");

    return result.Text;
}

Imports IronOcr

Public Function ExtractFromMultiPageTiff(tiffPath As String) As String
    Dim ocr = New IronTesseract()
    Using input = New OcrInput()
        input.LoadImageFrames(tiffPath) ' loads all frames automatically
        Dim result = ocr.Read(input)

        ' Access per-page text if needed
        For Each page In result.Pages
            Console.WriteLine($"Frame {page.PageNumber}: {page.Text}")
        Next

        Return result.Text
    End Using
End Function

// No path available — TesseractOCR cannot produce any PDF output.
// The closest workaround requires a separate PDF library (iTextSharp AGPL,
// or similar) to overlay extracted text onto the original PDF manually.
// This is 150-300 lines of additional code and introduces AGPL license concerns.

// The best available output from TesseractOCR:
using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
using var pix = TesseractOCR.Pix.Image.LoadFromFile("scanned-page.png");
using var page = engine.Process(pix);

string extractedText = page.Text; // flat string — no PDF output possible
File.WriteAllText("output.txt", extractedText);
// Cannot produce a searchable PDF — no API exists for this

Imports TesseractOCR
Imports System.IO

' No path available — TesseractOCR cannot produce any PDF output.
' The closest workaround requires a separate PDF library (iTextSharp AGPL,
' or similar) to overlay extracted text onto the original PDF manually.
' This is 150-300 lines of additional code and introduces AGPL license concerns.

' The best available output from TesseractOCR:
Using engine As New Engine("./tessdata", Language.English, EngineMode.Default)
    Using pix As TesseractOCR.Pix.Image = TesseractOCR.Pix.Image.LoadFromFile("scanned-page.png")
        Using page As Page = engine.Process(pix)
            Dim extractedText As String = page.Text ' flat string — no PDF output possible
            File.WriteAllText("output.txt", extractedText)
            ' Cannot produce a searchable PDF — no API exists for this
        End Using
    End Using
End Using

// Native searchable PDF output — no additional library required
// Input can be a scanned image, a scanned PDF, or a multi-page TIFF

using IronOcr;

public void CreateSearchablePdf(string scannedPdfPath, string outputPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdf(scannedPdfPath);
    input.Deskew();     // improve accuracy before generating the output
    input.DeNoise();

    var result = ocr.Read(input);
    result.SaveAsSearchablePdf(outputPath);   // searchable, text-selectable PDF
}

Imports IronOcr

Public Sub CreateSearchablePdf(scannedPdfPath As String, outputPath As String)
    Dim ocr As New IronTesseract()
    Using input As New OcrInput()
        input.LoadPdf(scannedPdfPath)
        input.Deskew() ' improve accuracy before generating the output
        input.DeNoise()

        Dim result = ocr.Read(input)
        result.SaveAsSearchablePdf(outputPath) ' searchable, text-selectable PDF
    End Using
End Sub

// TesseractOCR.Pix.Image has no byte[] or Stream overload
// Every in-memory image must be written to disk before processing

using TesseractOCR;
using TesseractOCR.Enums;

public string ExtractFromBytes(byte[] imageBytes)
{
    // Force a disk write just to satisfy the file-path API
    string tempPath = Path.GetTempFileName() + ".png";

    try
    {
        File.WriteAllBytes(tempPath, imageBytes);

        using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
        using var pix = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
        using var page = engine.Process(pix);

        return page.Text;
    }
    finally
    {
        // Risk: if an exception fires between WriteAllBytes and Delete,
        // temp files accumulate on the server disk
        if (File.Exists(tempPath))
            File.Delete(tempPath);
    }
}

Imports TesseractOCR
Imports TesseractOCR.Enums
Imports System.IO

Public Function ExtractFromBytes(imageBytes As Byte()) As String
    ' Force a disk write just to satisfy the file-path API
    Dim tempPath As String = Path.GetTempFileName() & ".png"

    Try
        File.WriteAllBytes(tempPath, imageBytes)

        Using engine As New Engine("./tessdata", Language.English, EngineMode.Default)
            Using pix As TesseractOCR.Pix.Image = TesseractOCR.Pix.Image.LoadFromFile(tempPath)
                Using page As Page = engine.Process(pix)
                    Return page.Text
                End Using
            End Using
        End Using
    Finally
        ' Risk: if an exception fires between WriteAllBytes and Delete,
        ' temp files accumulate on the server disk
        If File.Exists(tempPath) Then
            File.Delete(tempPath)
        End If
    End Try
End Function

// OcrInput accepts byte arrays and streams natively
// No disk write, no temp file cleanup, no cleanup failure risk

using IronOcr;

public string ExtractFromBytes(byte[] imageBytes)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imageBytes);   // direct byte array — no temp file
    return ocr.Read(input).Text;
}

public string ExtractFromStream(Stream imageStream)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imageStream);  // direct stream — no intermediate buffer
    return ocr.Read(input).Text;
}

Imports IronOcr

' OcrInput accepts byte arrays and streams natively
' No disk write, no temp file cleanup, no cleanup failure risk

Public Function ExtractFromBytes(imageBytes As Byte()) As String
    Dim ocr As New IronTesseract()
    Using input As New OcrInput()
        input.LoadImage(imageBytes)   ' direct byte array — no temp file
        Return ocr.Read(input).Text
    End Using
End Function

Public Function ExtractFromStream(imageStream As Stream) As String
    Dim ocr As New IronTesseract()
    Using input As New OcrInput()
        input.LoadImage(imageStream)  ' direct stream — no intermediate buffer
        Return ocr.Read(input).Text
    End Using
End Function

// Only document-level confidence available
// No word coordinates, no structural hierarchy

using TesseractOCR;
using TesseractOCR.Enums;

public void ProcessWithConfidence(string imagePath)
{
    using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
    using var pix = TesseractOCR.Pix.Image.LoadFromFile(imagePath);
    using var page = engine.Process(pix);

    float docConfidence = page.MeanConfidence; // 0.0 to 1.0 for the whole document

    if (docConfidence >= 0.7f)
        Console.WriteLine($"Accepted ({docConfidence:P0}): {page.Text}");
    else
        Console.WriteLine($"Rejected ({docConfidence:P0}): document needs preprocessing");

    // No way to identify WHICH words are uncertain
    // No word coordinates available
}

Imports TesseractOCR
Imports TesseractOCR.Enums

Public Sub ProcessWithConfidence(imagePath As String)
    Using engine As New Engine("./tessdata", Language.English, EngineMode.Default)
        Using pix As TesseractOCR.Pix.Image = TesseractOCR.Pix.Image.LoadFromFile(imagePath)
            Using page As Page = engine.Process(pix)
                Dim docConfidence As Single = page.MeanConfidence ' 0.0 to 1.0 for the whole document

                If docConfidence >= 0.7F Then
                    Console.WriteLine($"Accepted ({docConfidence:P0}): {page.Text}")
                Else
                    Console.WriteLine($"Rejected ({docConfidence:P0}): document needs preprocessing")
                End If

                ' No way to identify WHICH words are uncertain
                ' No word coordinates available
            End Using
        End Using
    End Using
End Sub

// Per-word confidence and coordinate data
// Filter individual uncertain words without discarding the whole document

using IronOcr;

public void ProcessWithWordLevelConfidence(string imagePath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    var result = ocr.Read(input);

    Console.WriteLine($"Document confidence: {result.Confidence}%");

    // Iterate words and flag those below threshold
    foreach (var page in result.Pages)
    {
        foreach (var word in page.Words)
        {
            if (word.Confidence < 70)
            {
                // Low-confidence word — log position for review
                Console.WriteLine(
                    $"Low confidence word '{word.Text}' ({word.Confidence}%) " +
                    $"at X:{word.X} Y:{word.Y}");
            }
        }
    }

    // Extract only high-confidence text
    var reliableWords = result.Pages
        .SelectMany(p => p.Words)
        .Where(w => w.Confidence >= 70)
        .Select(w => w.Text);

    Console.WriteLine(string.Join(" ", reliableWords));
}

Imports IronOcr

Public Sub ProcessWithWordLevelConfidence(imagePath As String)
    Dim ocr = New IronTesseract()
    Using input As New OcrInput()
        input.LoadImage(imagePath)
        Dim result = ocr.Read(input)

        Console.WriteLine($"Document confidence: {result.Confidence}%")

        ' Iterate words and flag those below threshold
        For Each page In result.Pages
            For Each word In page.Words
                If word.Confidence < 70 Then
                    ' Low-confidence word — log position for review
                    Console.WriteLine($"Low confidence word '{word.Text}' ({word.Confidence}%) at X:{word.X} Y:{word.Y}")
                End If
            Next
        Next

        ' Extract only high-confidence text
        Dim reliableWords = result.Pages _
            .SelectMany(Function(p) p.Words) _
            .Where(Function(w) w.Confidence >= 70) _
            .Select(Function(w) w.Text)

        Console.WriteLine(String.Join(" ", reliableWords))
    End Using
End Sub

// Before (TesseractOCR): page.MeanConfidence >= 0.7f
// After (IronOCR):
var result = new IronTesseract().Read("document.png");
if (result.Confidence >= 70.0)
{
    Console.WriteLine(result.Text);
}

Imports IronOcr

Dim result = New IronTesseract().Read("document.png")
If result.Confidence >= 70.0 Then
    Console.WriteLine(result.Text)
End If

grep -rn "GetTempFileName\|GetTempPath\|SaveBgraAsPng" --include="*.cs" .

// Before: byte[] → temp file → Pix.Image.LoadFromFile
// After: byte[] → OcrInput directly
using var input = new OcrInput();
input.LoadImage(imageBytes);   // no disk write
var result = ocr.Read(input);

Imports System

Using input As New OcrInput()
    input.LoadImage(imageBytes) ' no disk write
    Dim result = ocr.Read(input)
End Using

// Before (TesseractOCR):
var engine = new Engine(@"./tessdata",
    Language.English | Language.French | Language.German,
    EngineMode.Default);

// After (IronOCR):
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English + OcrLanguage.French + OcrLanguage.German;

Imports Tesseract
Imports IronOcr

' Before (TesseractOCR):
Dim engine As New Engine("./tessdata", Language.English Or Language.French Or Language.German, EngineMode.Default)

' After (IronOCR):
Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.English + OcrLanguage.French + OcrLanguage.German

grep -rn "using Docnet\|using SixLabors\|using SkiaSharp" --include="*.cs" .

// Before: five exception types to handle
catch (TesseractOCR.Exceptions.TesseractException ex) { ... }
catch (DllNotFoundException ex) { ... }
catch (BadImageFormatException ex) { ... }
catch (OutOfMemoryException ex) { ... }

// After: two exception types
catch (IronOcr.Exceptions.OcrException ex) { ... }
catch (IOException ex) { ... }

' Before: five exception types to handle
Catch ex As TesseractOCR.Exceptions.TesseractException
    ' ...
Catch ex As DllNotFoundException
    ' ...
Catch ex As BadImageFormatException
    ' ...
Catch ex As OutOfMemoryException
    ' ...

' After: two exception types
Catch ex As IronOcr.Exceptions.OcrException
    ' ...
Catch ex As IOException
    ' ...

grep -rn "using TesseractOCR" --include="*.cs" .
grep -rn "new Engine(" --include="*.cs" .
grep -rn "Pix\.Image\.LoadFromFile\|engine\.Process\|page\.Text\|MeanConfidence" --include="*.cs" .
grep -rn "Language\." --include="*.cs" .

grep -rn "using Docnet\|using SixLabors\|GetTempFileName\|SaveBgraAsPng" --include="*.cs" .
grep -rn "tessdata" --include="*.cs" .
grep -rn "tessdata" --include="*.csproj" .
grep -rn "tessdata" Dockerfile 2>/dev/null || true