LEADTOOLS OCR vs IronOCR: .NET OCR Library

using Leadtools;
using Leadtools.Ocr;
using Leadtools.Codecs;

public class LeadtoolsOcrService : IDisposable
{
    private IOcrEngine _ocrEngine;
    private RasterCodecs _codecs;

    public LeadtoolsOcrService()
    {
        // Step 1: Locate and validate both license files
        RasterSupport.SetLicense(
            @"C:\LEADTOOLS\License\LEADTOOLS.LIC",
            File.ReadAllText(@"C:\LEADTOOLS\License\LEADTOOLS.LIC.KEY"));

        // Step 2: Initialize image codec layer
        _codecs = new RasterCodecs();

        // Step 3: Select engine type — wrong choice means different behavior
        _ocrEngine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD);

        // Step 4: Load runtime into memory (500–2000ms)
        _ocrEngine.Startup(_codecs, null, null,
            @"C:\LEADTOOLS\OCR\OcrRuntime");
    }

    public string ExtractText(string imagePath)
    {
        using var image = _codecs.Load(imagePath);
        using var document = _ocrEngine.DocumentManager.CreateDocument();
        var page = document.Pages.AddPage(image, null);
        page.Recognize(null);   // Recognition is not automatic
        return page.GetText(-1);
    }

    public void Dispose()
    {
        _ocrEngine?.Shutdown(); // Must call before Dispose
        _ocrEngine?.Dispose();
        _codecs?.Dispose();
    }
}

Imports Leadtools
Imports Leadtools.Ocr
Imports Leadtools.Codecs
Imports System.IO

Public Class LeadtoolsOcrService
    Implements IDisposable

    Private _ocrEngine As IOcrEngine
    Private _codecs As RasterCodecs

    Public Sub New()
        ' Step 1: Locate and validate both license files
        RasterSupport.SetLicense(
            "C:\LEADTOOLS\License\LEADTOOLS.LIC",
            File.ReadAllText("C:\LEADTOOLS\License\LEADTOOLS.LIC.KEY"))

        ' Step 2: Initialize image codec layer
        _codecs = New RasterCodecs()

        ' Step 3: Select engine type — wrong choice means different behavior
        _ocrEngine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD)

        ' Step 4: Load runtime into memory (500–2000ms)
        _ocrEngine.Startup(_codecs, Nothing, Nothing,
            "C:\LEADTOOLS\OCR\OcrRuntime")
    End Sub

    Public Function ExtractText(imagePath As String) As String
        Using image = _codecs.Load(imagePath)
            Using document = _ocrEngine.DocumentManager.CreateDocument()
                Dim page = document.Pages.AddPage(image, Nothing)
                page.Recognize(Nothing) ' Recognition is not automatic
                Return page.GetText(-1)
            End Using
        End Using
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        If _ocrEngine IsNot Nothing Then
            _ocrEngine.Shutdown() ' Must call before Dispose
            _ocrEngine.Dispose()
        End If
        If _codecs IsNot Nothing Then
            _codecs.Dispose()
        End If
    End Sub
End Class

// From leadtools-migration-examples.cs
public void InitializeLicense()
{
    // Option 1: Absolute paths — deployment dependent
    string licPath = @"C:\LEADTOOLS\License\LEADTOOLS.LIC";
    string keyPath = @"C:\LEADTOOLS\License\LEADTOOLS.LIC.KEY";

    // Option 2: Relative paths — working directory dependent
    licPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "LEADTOOLS.LIC");
    keyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "LEADTOOLS.LIC.KEY");

    // Read key file content (not the path — the content)
    string key = File.ReadAllText(keyPath);

    // Set license — silent failure on some error types
    RasterSupport.SetLicense(licPath, key);

    // Verify license is valid for the module you purchased
    if (!RasterSupport.IsLocked(RasterSupportType.Document))
    {
        throw new InvalidOperationException("Document module not licensed");
    }
}

Imports System
Imports System.IO

Public Sub InitializeLicense()
    ' Option 1: Absolute paths — deployment dependent
    Dim licPath As String = "C:\LEADTOOLS\License\LEADTOOLS.LIC"
    Dim keyPath As String = "C:\LEADTOOLS\License\LEADTOOLS.LIC.KEY"

    ' Option 2: Relative paths — working directory dependent
    licPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "LEADTOOLS.LIC")
    keyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "LEADTOOLS.LIC.KEY")

    ' Read key file content (not the path — the content)
    Dim key As String = File.ReadAllText(keyPath)

    ' Set license — silent failure on some error types
    RasterSupport.SetLicense(licPath, key)

    ' Verify license is valid for the module you purchased
    If Not RasterSupport.IsLocked(RasterSupportType.Document) Then
        Throw New InvalidOperationException("Document module not licensed")
    End If
End Sub

// From application startup — store key using any secrets management pattern
IronOcr.License.LicenseKey = "IRONSUITE.YOUR-LICENSE-KEY";

// Production: pull from environment variable
IronOcr.License.LicenseKey =
    Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// Or from ASP.NET configuration
IronOcr.License.LicenseKey = Configuration["IronOCR:LicenseKey"];

' From application startup — store key using any secrets management pattern
IronOcr.License.LicenseKey = "IRONSUITE.YOUR-LICENSE-KEY"

' Production: pull from environment variable
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

' Or from ASP.NET configuration
IronOcr.License.LicenseKey = Configuration("IronOCR:LicenseKey")

using Leadtools;
using Leadtools.Ocr;
using Leadtools.Codecs;

public class LeadtoolsOcrService : IDisposable
{
    private IOcrEngine _ocrEngine;
    private RasterCodecs _codecs;

    public LeadtoolsOcrService()
    {
        // Step 1: License files
        RasterSupport.SetLicense(
            @"C:\LEADTOOLS\License\LEADTOOLS.LIC",
            File.ReadAllText(@"C:\LEADTOOLS\License\LEADTOOLS.LIC.KEY"));

        // Step 2: Codec layer
        _codecs = new RasterCodecs();

        // Step 3: Engine factory
        _ocrEngine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD);

        // Step 4: Engine startup (500–2000ms blocking call)
        _ocrEngine.Startup(_codecs, null, null,
            @"C:\LEADTOOLS\OCR\OcrRuntime");
    }

    public string ExtractText(string imagePath)
    {
        using var image = _codecs.Load(imagePath);          // Step 5: Load via codecs
        using var document = _ocrEngine.DocumentManager     // Step 6: Create document
                                       .CreateDocument();
        var page = document.Pages.AddPage(image, null);     // Step 7: Add page
        page.Recognize(null);                               // Step 8: Explicit recognize
        return page.GetText(-1);                            // Step 9: Extract text
    }

    public void Dispose()
    {
        _ocrEngine?.Shutdown();  // Step 10: Shutdown before dispose
        _ocrEngine?.Dispose();
        _codecs?.Dispose();
    }
}

Imports Leadtools
Imports Leadtools.Ocr
Imports Leadtools.Codecs
Imports System.IO

Public Class LeadtoolsOcrService
    Implements IDisposable

    Private _ocrEngine As IOcrEngine
    Private _codecs As RasterCodecs

    Public Sub New()
        ' Step 1: License files
        RasterSupport.SetLicense(
            "C:\LEADTOOLS\License\LEADTOOLS.LIC",
            File.ReadAllText("C:\LEADTOOLS\License\LEADTOOLS.LIC.KEY"))

        ' Step 2: Codec layer
        _codecs = New RasterCodecs()

        ' Step 3: Engine factory
        _ocrEngine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD)

        ' Step 4: Engine startup (500–2000ms blocking call)
        _ocrEngine.Startup(_codecs, Nothing, Nothing,
            "C:\LEADTOOLS\OCR\OcrRuntime")
    End Sub

    Public Function ExtractText(imagePath As String) As String
        Using image = _codecs.Load(imagePath) ' Step 5: Load via codecs
            Using document = _ocrEngine.DocumentManager ' Step 6: Create document
                                           .CreateDocument()
                Dim page = document.Pages.AddPage(image, Nothing) ' Step 7: Add page
                page.Recognize(Nothing) ' Step 8: Explicit recognize
                Return page.GetText(-1) ' Step 9: Extract text
            End Using
        End Using
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _ocrEngine?.Shutdown() ' Step 10: Shutdown before dispose
        _ocrEngine?.Dispose()
        _codecs?.Dispose()
    End Sub
End Class

using IronOcr;

public class OcrService
{
    public string ExtractText(string imagePath)
    {
        return new IronTesseract().Read(imagePath).Text;
    }
}

Imports IronOcr

Public Class OcrService
    Public Function ExtractText(imagePath As String) As String
        Return New IronTesseract().Read(imagePath).Text
    End Function
End Class

public class OcrService
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public string ExtractText(string imagePath)
    {
        return _ocr.Read(imagePath).Text;
    }
}

Imports IronTesseract

Public Class OcrService
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractText(imagePath As String) As String
        Return _ocr.Read(imagePath).Text
    End Function
End Class

public string ExtractTextFromPdf(string pdfPath)
{
    var text = new StringBuilder();

    // Get page count first — separate call
    var pdfInfo = _codecs.GetInformation(pdfPath, true);
    int totalPages = pdfInfo.TotalPages;

    using var document = _ocrEngine.DocumentManager.CreateDocument();

    for (int pageNum = 1; pageNum <= totalPages; pageNum++)
    {
        // Load each page as a raster image — must dispose each
        using var pageImage = _codecs.Load(
            pdfPath,
            0,                            // bitsPerPixel
            CodecsLoadByteOrder.BgrOrGray,
            pageNum,                      // firstPage
            pageNum);                     // lastPage

        var page = document.Pages.AddPage(pageImage, null);
        page.Recognize(null);
        text.AppendLine(page.GetText(-1));
    }

    return text.ToString();
}

Imports System.Text

Public Function ExtractTextFromPdf(ByVal pdfPath As String) As String
    Dim text As New StringBuilder()

    ' Get page count first — separate call
    Dim pdfInfo = _codecs.GetInformation(pdfPath, True)
    Dim totalPages As Integer = pdfInfo.TotalPages

    Using document = _ocrEngine.DocumentManager.CreateDocument()

        For pageNum As Integer = 1 To totalPages
            ' Load each page as a raster image — must dispose each
            Using pageImage = _codecs.Load(pdfPath, 0, CodecsLoadByteOrder.BgrOrGray, pageNum, pageNum)
                Dim page = document.Pages.AddPage(pageImage, Nothing)
                page.Recognize(Nothing)
                text.AppendLine(page.GetText(-1))
            End Using
        Next
    End Using

    Return text.ToString()
End Function

// Requires Leadtools.Pdf module — additional license
using Leadtools.Pdf;

public string ExtractFromEncryptedPdf(string pdfPath, string password)
{
    var pdfFile = new PDFFile(pdfPath);
    pdfFile.Password = password;

    var loadOptions = new CodecsLoadOptions();
    _codecs.Options.Pdf.Load.Password = password;
    // ... same page iteration loop follows
}

Imports Leadtools.Pdf

Public Function ExtractFromEncryptedPdf(ByVal pdfPath As String, ByVal password As String) As String
    Dim pdfFile As New PDFFile(pdfPath)
    pdfFile.Password = password

    Dim loadOptions As New CodecsLoadOptions()
    _codecs.Options.Pdf.Load.Password = password
    ' ... same page iteration loop follows
End Function

// From leadtools-pdf-processing.cs
var pdfOptions = new PdfDocumentOptions
{
    DocumentType = PdfDocumentType.Pdf,
    ImageOverText = true,
    Linearized = false,
    Title = Path.GetFileNameWithoutExtension(inputPdfPath)
};

_engine.DocumentWriterInstance.SetOptions(DocumentFormat.Pdf, pdfOptions);
document.Save(outputPdfPath, DocumentFormat.Pdf, null);

Imports System.IO

Dim pdfOptions As New PdfDocumentOptions With {
    .DocumentType = PdfDocumentType.Pdf,
    .ImageOverText = True,
    .Linearized = False,
    .Title = Path.GetFileNameWithoutExtension(inputPdfPath)
}

_engine.DocumentWriterInstance.SetOptions(DocumentFormat.Pdf, pdfOptions)
document.Save(outputPdfPath, DocumentFormat.Pdf, Nothing)

using IronOcr;

// Basic PDF — all pages, automatic handling
public string ExtractTextFromPdf(string pdfPath)
{
    using var input = new OcrInput();
    input.LoadPdf(pdfPath);
    return new IronTesseract().Read(input).Text;
}

// Password-protected PDF — no additional module required
public string ExtractFromEncryptedPdf(string pdfPath, string password)
{
    using var input = new OcrInput();
    input.LoadPdf(pdfPath, Password: password);
    return new IronTesseract().Read(input).Text;
}

// Searchable PDF output — one method call
public void CreateSearchablePdf(string inputPdfPath, string outputPdfPath)
{
    using var input = new OcrInput();
    input.LoadPdf(inputPdfPath);
    var result = new IronTesseract().Read(input);
    result.SaveAsSearchablePdf(outputPdfPath);
}

Imports IronOcr

' Basic PDF — all pages, automatic handling
Public Function ExtractTextFromPdf(pdfPath As String) As String
    Using input As New OcrInput()
        input.LoadPdf(pdfPath)
        Return New IronTesseract().Read(input).Text
    End Using
End Function

' Password-protected PDF — no additional module required
Public Function ExtractFromEncryptedPdf(pdfPath As String, password As String) As String
    Using input As New OcrInput()
        input.LoadPdf(pdfPath, Password:=password)
        Return New IronTesseract().Read(input).Text
    End Using
End Function

' Searchable PDF output — one method call
Public Sub CreateSearchablePdf(inputPdfPath As String, outputPdfPath As String)
    Using input As New OcrInput()
        input.LoadPdf(inputPdfPath)
        Dim result = New IronTesseract().Read(input)
        result.SaveAsSearchablePdf(outputPdfPath)
    End Using
End Sub

using Leadtools.ImageProcessing;

public string ProcessLowQualityPdf(string pdfPath)
{
    var text = new StringBuilder();
    var pdfInfo = _codecs.GetInformation(pdfPath, true);

    using var document = _engine.DocumentManager.CreateDocument();

    for (int i = 1; i <= pdfInfo.TotalPages; i++)
    {
        using var pageImage = _codecs.Load(pdfPath, 0,
            CodecsLoadByteOrder.BgrOrGray, i, i);

        // Each command is a separate instantiation and Run() call
        var deskewCommand = new DeskewCommand();
        deskewCommand.Run(pageImage);

        var despeckleCommand = new DespeckleCommand();
        despeckleCommand.Run(pageImage);

        if (pageImage.BitsPerPixel > 8)
        {
            var grayscaleCommand = new GrayscaleCommand(8);
            grayscaleCommand.Run(pageImage);
        }

        var binarizeCommand = new AutoBinarizeCommand();
        binarizeCommand.Run(pageImage);

        var page = document.Pages.AddPage(pageImage, null);
        page.Recognize(null);
        text.AppendLine(page.GetText(-1));
    }

    return text.ToString();
}

Imports Leadtools.ImageProcessing
Imports System.Text

Public Function ProcessLowQualityPdf(pdfPath As String) As String
    Dim text As New StringBuilder()
    Dim pdfInfo = _codecs.GetInformation(pdfPath, True)

    Using document = _engine.DocumentManager.CreateDocument()
        For i As Integer = 1 To pdfInfo.TotalPages
            Using pageImage = _codecs.Load(pdfPath, 0, CodecsLoadByteOrder.BgrOrGray, i, i)
                ' Each command is a separate instantiation and Run() call
                Dim deskewCommand As New DeskewCommand()
                deskewCommand.Run(pageImage)

                Dim despeckleCommand As New DespeckleCommand()
                despeckleCommand.Run(pageImage)

                If pageImage.BitsPerPixel > 8 Then
                    Dim grayscaleCommand As New GrayscaleCommand(8)
                    grayscaleCommand.Run(pageImage)
                End If

                Dim binarizeCommand As New AutoBinarizeCommand()
                binarizeCommand.Run(pageImage)

                Dim page = document.Pages.AddPage(pageImage, Nothing)
                page.Recognize(Nothing)
                text.AppendLine(page.GetText(-1))
            End Using
        Next
    End Using

    Return text.ToString()
End Function

using IronOcr;

public string ProcessLowQualityPdf(string pdfPath)
{
    var ocr = new IronTesseract();

    using var input = new OcrInput();
    input.LoadPdf(pdfPath);

    // Applied to all pages
    input.Deskew();
    input.DeNoise();
    input.Binarize();
    input.Contrast();
    input.EnhanceResolution(300);

    var result = ocr.Read(input);
    Console.WriteLine($"Confidence: {result.Confidence}%");
    return result.Text;
}

Imports IronOcr

Public Function ProcessLowQualityPdf(pdfPath As String) As String
    Dim ocr = New IronTesseract()

    Using input As New OcrInput()
        input.LoadPdf(pdfPath)

        ' Applied to all pages
        input.Deskew()
        input.DeNoise()
        input.Binarize()
        input.Contrast()
        input.EnhanceResolution(300)

        Dim result = ocr.Read(input)
        Console.WriteLine($"Confidence: {result.Confidence}%")
        Return result.Text
    End Using
End Function

// LEADTOOLS: Service class required for lifecycle management
public class LeadtoolsService : IDisposable
{
    private IOcrEngine _engine;
    private RasterCodecs _codecs;

    public LeadtoolsService()
    {
        RasterSupport.SetLicense(licPath, key);
        _codecs = new RasterCodecs();
        _engine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD);
        _engine.Startup(_codecs, null, null, runtimePath);
    }

    public string Process(string path)
    {
        using var image = _codecs.Load(path);
        using var doc = _engine.DocumentManager.CreateDocument();
        var page = doc.Pages.AddPage(image, null);
        page.Recognize(null);
        return page.GetText(-1);
    }

    public void Dispose()
    {
        _engine?.Shutdown();
        _engine?.Dispose();
        _codecs?.Dispose();
    }
}

// IronOCR: No lifecycle to manage
public class OcrService
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public string Process(string path) => _ocr.Read(path).Text;
}

Imports System
Imports Leadtools
Imports Leadtools.Codecs
Imports Leadtools.Ocr
Imports IronOcr

' LEADTOOLS: Service class required for lifecycle management
Public Class LeadtoolsService
    Implements IDisposable

    Private _engine As IOcrEngine
    Private _codecs As RasterCodecs

    Public Sub New()
        RasterSupport.SetLicense(licPath, key)
        _codecs = New RasterCodecs()
        _engine = OcrEngineManager.CreateEngine(OcrEngineType.LEAD)
        _engine.Startup(_codecs, Nothing, Nothing, runtimePath)
    End Sub

    Public Function Process(path As String) As String
        Using image = _codecs.Load(path)
            Using doc = _engine.DocumentManager.CreateDocument()
                Dim page = doc.Pages.AddPage(image, Nothing)
                page.Recognize(Nothing)
                Return page.GetText(-1)
            End Using
        End Using
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _engine?.Shutdown()
        _engine?.Dispose()
        _codecs?.Dispose()
    End Sub
End Class

' IronOCR: No lifecycle to manage
Public Class OcrService

    Private ReadOnly _ocr As New IronTesseract()

    Public Function Process(path As String) As String
        Return _ocr.Read(path).Text
    End Function
End Class

// LEADTOOLS zone setup
var zone = new OcrZone
{
    Bounds = new LeadRect(x, y, width, height),
    ZoneType = OcrZoneType.Text,
    CharacterFilters = OcrZoneCharacterFilters.None,
    RecognitionModule = OcrZoneRecognitionModule.Auto
};
page.Zones.Clear();  // Must clear auto-detected zones first
page.Zones.Add(zone);

// IronOCR equivalent
using var input = new OcrInput();
input.LoadImage(imagePath, new CropRectangle(x, y, width, height));
var text = new IronTesseract().Read(input).Text;

Imports Leadtools
Imports IronOcr

' LEADTOOLS zone setup
Dim zone As New OcrZone With {
    .Bounds = New LeadRect(x, y, width, height),
    .ZoneType = OcrZoneType.Text,
    .CharacterFilters = OcrZoneCharacterFilters.None,
    .RecognitionModule = OcrZoneRecognitionModule.Auto
}
page.Zones.Clear() ' Must clear auto-detected zones first
page.Zones.Add(zone)

' IronOCR equivalent
Using input As New OcrInput()
    input.LoadImage(imagePath, New CropRectangle(x, y, width, height))
    Dim text As String = New IronTesseract().Read(input).Text
End Using

# Remove LEADTOOLS packages
dotnet remove package Leadtools
dotnet remove package Leadtools.Ocr
dotnet remove package Leadtools.Codecs
dotnet remove package Leadtools.Pdf

# Add IronOCR
dotnet add package IronOcr

var result = new IronTesseract().Read("document.jpg");
Console.WriteLine($"Confidence: {result.Confidence}%");

// Branch on quality threshold
if (result.Confidence < 60)
{
    // Apply additional preprocessing and retry
    using var input = new OcrInput();
    input.LoadImage("document.jpg");
    input.Deskew();
    input.DeNoise();
    input.EnhanceResolution(300);
    result = new IronTesseract().Read(input);
}

Imports System
Imports IronOcr

Dim result = New IronTesseract().Read("document.jpg")
Console.WriteLine($"Confidence: {result.Confidence}%")

' Branch on quality threshold
If result.Confidence < 60 Then
    ' Apply additional preprocessing and retry
    Using input As New OcrInput()
        input.LoadImage("document.jpg")
        input.Deskew()
        input.DeNoise()
        input.EnhanceResolution(300)
        result = New IronTesseract().Read(input)
    End Using
End If