Migrating from RapidOCR.NET to IronOCR

// RapidOcrNet: 4 external files required before any OCR can execute
var engine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = "./models/det.onnx",     // ~3 MB — downloaded from GitHub
    ClsModelPath = "./models/cls.onnx",     // ~1 MB — downloaded from GitHub
    RecModelPath = "./models/rec_en.onnx",  // ~2-10 MB — language-specific download
    KeysPath     = "./models/en_keys.txt"   // character dictionary — language-specific
});

' RapidOcrNet: 4 external files required before any OCR can execute
Dim engine = New RapidOcrEngine(New RapidOcrOptions With {
    .DetModelPath = "./models/det.onnx",     ' ~3 MB — downloaded from GitHub
    .ClsModelPath = "./models/cls.onnx",     ' ~1 MB — downloaded from GitHub
    .RecModelPath = "./models/rec_en.onnx",  ' ~2-10 MB — language-specific download
    .KeysPath = "./models/en_keys.txt"       ' character dictionary — language-specific
})

// IronOCR: install the NuGet package, write one line
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read("document.jpg").Text;

' IronOCR: install the NuGet package, write one line
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim text = New IronTesseract().Read("document.jpg").Text

dotnet remove package RapidOcrNet
dotnet remove package Microsoft.ML.OnnxRuntime

// Before (RapidOCR.NET)
using RapidOcrNet;

// After (IronOCR)
using IronOcr;

Imports IronOcr

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

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

using RapidOcrNet;

// Startup validation — written because a missing model crashes at runtime, not at install
private static void EnsureModelsPresent(string modelDir)
{
    var required = new[]
    {
        Path.Combine(modelDir, "det.onnx"),
        Path.Combine(modelDir, "cls.onnx"),
        Path.Combine(modelDir, "rec_en.onnx"),
        Path.Combine(modelDir, "en_keys.txt")
    };

    var missing = required.Where(f => !File.Exists(f)).ToList();
    if (missing.Any())
        throw new FileNotFoundException(
            $"Missing model files: {string.Join(", ", missing)}\n" +
            "Download from: https://github.com/RapidAI/RapidOCR/releases");
}

// Engine factory — called once at startup, held for lifetime of service
public RapidOcrEngine CreateEngine(string modelDir)
{
    EnsureModelsPresent(modelDir);
    return new RapidOcrEngine(new RapidOcrOptions
    {
        DetModelPath = Path.Combine(modelDir, "det.onnx"),
        ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
        RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
        KeysPath     = Path.Combine(modelDir, "en_keys.txt"),
        UseGpu       = false,
        NumThreads   = Environment.ProcessorCount
    });
}

Imports RapidOcrNet

' Startup validation — written because a missing model crashes at runtime, not at install
Private Shared Sub EnsureModelsPresent(modelDir As String)
    Dim required = {
        Path.Combine(modelDir, "det.onnx"),
        Path.Combine(modelDir, "cls.onnx"),
        Path.Combine(modelDir, "rec_en.onnx"),
        Path.Combine(modelDir, "en_keys.txt")
    }

    Dim missing = required.Where(Function(f) Not File.Exists(f)).ToList()
    If missing.Any() Then
        Throw New FileNotFoundException(
            $"Missing model files: {String.Join(", ", missing)}" & vbCrLf &
            "Download from: https://github.com/RapidAI/RapidOCR/releases")
    End If
End Sub

' Engine factory — called once at startup, held for lifetime of service
Public Function CreateEngine(modelDir As String) As RapidOcrEngine
    EnsureModelsPresent(modelDir)
    Return New RapidOcrEngine(New RapidOcrOptions With {
        .DetModelPath = Path.Combine(modelDir, "det.onnx"),
        .ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
        .RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
        .KeysPath = Path.Combine(modelDir, "en_keys.txt"),
        .UseGpu = False,
        .NumThreads = Environment.ProcessorCount
    })
End Function

using IronOcr;

// No model validation, no path configuration, no GPU flags
// IronTesseract is thread-safe; create one per thread or on demand
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var ocr = new IronTesseract();

Imports IronOcr

' No model validation, no path configuration, no GPU flags
' IronTesseract is thread-safe; create one per thread or on demand
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim ocr As New IronTesseract()

using RapidOcrNet;

public class InvoiceTextExtractor
{
    private readonly RapidOcrEngine _engine;

    public InvoiceTextExtractor(string modelDir)
    {
        // Three separate ONNX models run in sequence on every call
        _engine = new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(modelDir, "det.onnx"),   // Stage 1: detect text regions
            ClsModelPath = Path.Combine(modelDir, "cls.onnx"),   // Stage 2: classify direction
            RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),// Stage 3: recognize characters
            KeysPath     = Path.Combine(modelDir, "en_keys.txt")
        });
    }

    public string ExtractInvoiceText(string imagePath)
    {
        var result = _engine.Run(imagePath);

        // Blocks are unordered — must sort by vertical position, then horizontal
        var orderedBlocks = result.TextBlocks
            .OrderBy(b => b.BoundingBox.Top)
            .ThenBy(b => b.BoundingBox.Left)
            .ToList();

        // Manual assembly — no paragraph or line structure
        return string.Join(Environment.NewLine,
            orderedBlocks.Select(b => b.Text));
    }
}

Imports RapidOcrNet
Imports System.IO
Imports System.Linq

Public Class InvoiceTextExtractor
    Private ReadOnly _engine As RapidOcrEngine

    Public Sub New(modelDir As String)
        ' Three separate ONNX models run in sequence on every call
        _engine = New RapidOcrEngine(New RapidOcrOptions With {
            .DetModelPath = Path.Combine(modelDir, "det.onnx"),   ' Stage 1: detect text regions
            .ClsModelPath = Path.Combine(modelDir, "cls.onnx"),   ' Stage 2: classify direction
            .RecModelPath = Path.Combine(modelDir, "rec_en.onnx"), ' Stage 3: recognize characters
            .KeysPath = Path.Combine(modelDir, "en_keys.txt")
        })
    End Sub

    Public Function ExtractInvoiceText(imagePath As String) As String
        Dim result = _engine.Run(imagePath)

        ' Blocks are unordered — must sort by vertical position, then horizontal
        Dim orderedBlocks = result.TextBlocks _
            .OrderBy(Function(b) b.BoundingBox.Top) _
            .ThenBy(Function(b) b.BoundingBox.Left) _
            .ToList()

        ' Manual assembly — no paragraph or line structure
        Return String.Join(Environment.NewLine, orderedBlocks.Select(Function(b) b.Text))
    End Function
End Class

using IronOcr;

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

    public string ExtractInvoiceText(string imagePath)
    {
        // Single call — detection, recognition, reading order all internal
        var result = _ocr.Read(imagePath);
        return result.Text; // Already in reading order
    }

    public IEnumerable<string> ExtractInvoiceParagraphs(string imagePath)
    {
        var result = _ocr.Read(imagePath);
        // Structured paragraphs with coordinates — no sorting or assembly needed
        foreach (var page in result.Pages)
            foreach (var paragraph in page.Paragraphs)
                yield return paragraph.Text;
    }
}

Imports IronOcr

Public Class InvoiceTextExtractor
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractInvoiceText(imagePath As String) As String
        ' Single call — detection, recognition, reading order all internal
        Dim result = _ocr.Read(imagePath)
        Return result.Text ' Already in reading order
    End Function

    Public Iterator Function ExtractInvoiceParagraphs(imagePath As String) As IEnumerable(Of String)
        Dim result = _ocr.Read(imagePath)
        ' Structured paragraphs with coordinates — no sorting or assembly needed
        For Each page In result.Pages
            For Each paragraph In page.Paragraphs
                Yield paragraph.Text
            Next
        Next
    End Function
End Class

using RapidOcrNet;

public class DocumentRouter
{
    private readonly string _modelDir;

    public DocumentRouter(string modelDir) => _modelDir = modelDir;

    // Must create separate engine instances per configuration
    // Each engine holds ~300-500 MB of loaded model weights
    private RapidOcrEngine BuildEnglishEngine() =>
        new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(_modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(_modelDir, "en_rec.onnx"),
            KeysPath     = Path.Combine(_modelDir, "en_keys.txt")
        });

    private RapidOcrEngine BuildChineseEngine() =>
        new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(_modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(_modelDir, "ch_rec.onnx"),  // separate download
            KeysPath     = Path.Combine(_modelDir, "ch_keys.txt")   // separate download
        });

    public string ProcessDocument(string imagePath, string language)
    {
        // Rebuild engine for each language — model reload cost on every switch
        using var engine = language == "chinese"
            ? BuildChineseEngine()
            : BuildEnglishEngine();

        var result = engine.Run(imagePath);
        return string.Join("\n", result.TextBlocks
            .OrderBy(b => b.BoundingBox.Top)
            .Select(b => b.Text));
    }
}

Imports RapidOcrNet

Public Class DocumentRouter
    Private ReadOnly _modelDir As String

    Public Sub New(modelDir As String)
        _modelDir = modelDir
    End Sub

    ' Must create separate engine instances per configuration
    ' Each engine holds ~300-500 MB of loaded model weights
    Private Function BuildEnglishEngine() As RapidOcrEngine
        Return New RapidOcrEngine(New RapidOcrOptions With {
            .DetModelPath = Path.Combine(_modelDir, "det.onnx"),
            .ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
            .RecModelPath = Path.Combine(_modelDir, "en_rec.onnx"),
            .KeysPath = Path.Combine(_modelDir, "en_keys.txt")
        })
    End Function

    Private Function BuildChineseEngine() As RapidOcrEngine
        Return New RapidOcrEngine(New RapidOcrOptions With {
            .DetModelPath = Path.Combine(_modelDir, "det.onnx"),
            .ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
            .RecModelPath = Path.Combine(_modelDir, "ch_rec.onnx"),  ' separate download
            .KeysPath = Path.Combine(_modelDir, "ch_keys.txt")   ' separate download
        })
    End Function

    Public Function ProcessDocument(imagePath As String, language As String) As String
        ' Rebuild engine for each language — model reload cost on every switch
        Using engine As RapidOcrEngine = If(language = "chinese", BuildChineseEngine(), BuildEnglishEngine())
            Dim result = engine.Run(imagePath)
            Return String.Join(vbLf, result.TextBlocks _
                .OrderBy(Function(b) b.BoundingBox.Top) _
                .Select(Function(b) b.Text))
        End Using
    End Function
End Class

using IronOcr;

public class DocumentRouter
{
    // One instance handles all languages — language is a property, not a constructor param
    private readonly IronTesseract _ocr = new IronTesseract();

    public string ProcessDocument(string imagePath, string language)
    {
        // Language switch requires no model reload, no rebuild
        _ocr.Language = language switch
        {
            "chinese"  => OcrLanguage.ChineseSimplified,
            "japanese" => OcrLanguage.Japanese,
            "arabic"   => OcrLanguage.Arabic,
            "russian"  => OcrLanguage.Russian,
            _          => OcrLanguage.English
        };

        return _ocr.Read(imagePath).Text;
    }
}

Imports IronOcr

Public Class DocumentRouter
    ' One instance handles all languages — language is a property, not a constructor param
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ProcessDocument(imagePath As String, language As String) As String
        ' Language switch requires no model reload, no rebuild
        _ocr.Language = If(language = "chinese", OcrLanguage.ChineseSimplified,
                           If(language = "japanese", OcrLanguage.Japanese,
                           If(language = "arabic", OcrLanguage.Arabic,
                           If(language = "russian", OcrLanguage.Russian,
                           OcrLanguage.English))))

        Return _ocr.Read(imagePath).Text
    End Function
End Class

using RapidOcrNet;

public class BatchOcrProcessor
{
    private readonly string _modelDir;

    public BatchOcrProcessor(string modelDir) => _modelDir = modelDir;

    // Thread-pool processing — each thread needs its own engine copy
    // 4 threads × 300-500 MB model footprint = 1.2-2 GB RAM minimum
    public Dictionary<string, string> ProcessBatch(IReadOnlyList<string> imagePaths)
    {
        var results = new System.Collections.Concurrent.ConcurrentDictionary<string, string>();

        Parallel.ForEach(imagePaths, new ParallelOptions { MaxDegreeOfParallelism = 4 },
            imagePath =>
            {
                // Each thread must create its own engine — not safe to share
                using var engine = new RapidOcrEngine(new RapidOcrOptions
                {
                    DetModelPath = Path.Combine(_modelDir, "det.onnx"),
                    ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
                    RecModelPath = Path.Combine(_modelDir, "rec_en.onnx"),
                    KeysPath     = Path.Combine(_modelDir, "en_keys.txt")
                });

                var result = engine.Run(imagePath);
                results[imagePath] = string.Join("\n",
                    result.TextBlocks
                          .OrderBy(b => b.BoundingBox.Top)
                          .Select(b => b.Text));
            });

        return new Dictionary<string, string>(results);
    }
}

Imports RapidOcrNet
Imports System.Collections.Concurrent
Imports System.IO
Imports System.Threading.Tasks

Public Class BatchOcrProcessor
    Private ReadOnly _modelDir As String

    Public Sub New(modelDir As String)
        _modelDir = modelDir
    End Sub

    ' Thread-pool processing — each thread needs its own engine copy
    ' 4 threads × 300-500 MB model footprint = 1.2-2 GB RAM minimum
    Public Function ProcessBatch(imagePaths As IReadOnlyList(Of String)) As Dictionary(Of String, String)
        Dim results = New ConcurrentDictionary(Of String, String)()

        Parallel.ForEach(imagePaths, New ParallelOptions With {.MaxDegreeOfParallelism = 4},
            Sub(imagePath)
                ' Each thread must create its own engine — not safe to share
                Using engine = New RapidOcrEngine(New RapidOcrOptions With {
                    .DetModelPath = Path.Combine(_modelDir, "det.onnx"),
                    .ClsModelPath = Path.Combine(_modelDir, "cls.onnx"),
                    .RecModelPath = Path.Combine(_modelDir, "rec_en.onnx"),
                    .KeysPath = Path.Combine(_modelDir, "en_keys.txt")
                })

                    Dim result = engine.Run(imagePath)
                    results(imagePath) = String.Join(vbLf,
                        result.TextBlocks _
                              .OrderBy(Function(b) b.BoundingBox.Top) _
                              .Select(Function(b) b.Text))
                End Using
            End Sub)

        Return New Dictionary(Of String, String)(results)
    End Function
End Class

using IronOcr;

public class BatchOcrProcessor
{
    // Thread-safe: create IronTesseract per thread, no shared state required
    public Dictionary<string, string> ProcessBatch(IReadOnlyList<string> imagePaths)
    {
        var results = new System.Collections.Concurrent.ConcurrentDictionary<string, string>();

        Parallel.ForEach(imagePaths, imagePath =>
        {
            // Lightweight construction — no model loading overhead per thread
            var ocr = new IronTesseract();
            var result = ocr.Read(imagePath);
            results[imagePath] = result.Text;
        });

        return new Dictionary<string, string>(results);
    }
}

Imports IronOcr
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.Threading.Tasks

Public Class BatchOcrProcessor
    ' Thread-safe: create IronTesseract per thread, no shared state required
    Public Function ProcessBatch(imagePaths As IReadOnlyList(Of String)) As Dictionary(Of String, String)
        Dim results = New ConcurrentDictionary(Of String, String)()

        Parallel.ForEach(imagePaths, Sub(imagePath)
            ' Lightweight construction — no model loading overhead per thread
            Dim ocr = New IronTesseract()
            Dim result = ocr.Read(imagePath)
            results(imagePath) = result.Text
        End Sub)

        Return New Dictionary(Of String, String)(results)
    End Function
End Class

using RapidOcrNet;
// Also requires: SixLabors.ImageSharp or System.Drawing for TIFF frame extraction

public class TiffOcrProcessor
{
    private readonly RapidOcrEngine _engine;

    public TiffOcrProcessor(string modelDir)
    {
        _engine = new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
            KeysPath     = Path.Combine(modelDir, "en_keys.txt")
        });
    }

    public string ProcessMultiPageTiff(string tiffPath)
    {
        var pageTexts = new List<string>();
        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
        Directory.CreateDirectory(tempDir);

        try
        {
            // External library required to split TIFF frames
            var framePaths = SplitTiffIntoFrames(tiffPath, tempDir); // not in RapidOcrNet

            foreach (var framePath in framePaths)
            {
                var result = _engine.Run(framePath);
                pageTexts.Add(string.Join("\n",
                    result.TextBlocks
                          .OrderBy(b => b.BoundingBox.Top)
                          .Select(b => b.Text)));
            }
        }
        finally
        {
            // Clean up temp frame files
            Directory.Delete(tempDir, recursive: true);
        }

        return string.Join("\n\n", pageTexts);
    }

    private IEnumerable<string> SplitTiffIntoFrames(string tiffPath, string outputDir)
    {
        // Requires external library — implementation depends on what is installed
        throw new NotImplementedException("Add SixLabors.ImageSharp or similar");
    }
}

Imports RapidOcrNet
' Also requires: SixLabors.ImageSharp or System.Drawing for TIFF frame extraction

Public Class TiffOcrProcessor
    Private ReadOnly _engine As RapidOcrEngine

    Public Sub New(modelDir As String)
        _engine = New RapidOcrEngine(New RapidOcrOptions With {
            .DetModelPath = Path.Combine(modelDir, "det.onnx"),
            .ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
            .RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
            .KeysPath = Path.Combine(modelDir, "en_keys.txt")
        })
    End Sub

    Public Function ProcessMultiPageTiff(tiffPath As String) As String
        Dim pageTexts As New List(Of String)()
        Dim tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString())
        Directory.CreateDirectory(tempDir)

        Try
            ' External library required to split TIFF frames
            Dim framePaths = SplitTiffIntoFrames(tiffPath, tempDir) ' not in RapidOcrNet

            For Each framePath In framePaths
                Dim result = _engine.Run(framePath)
                pageTexts.Add(String.Join(vbLf,
                    result.TextBlocks _
                          .OrderBy(Function(b) b.BoundingBox.Top) _
                          .Select(Function(b) b.Text)))
            Next
        Finally
            ' Clean up temp frame files
            Directory.Delete(tempDir, recursive:=True)
        End Try

        Return String.Join(vbLf & vbLf, pageTexts)
    End Function

    Private Function SplitTiffIntoFrames(tiffPath As String, outputDir As String) As IEnumerable(Of String)
        ' Requires external library — implementation depends on what is installed
        Throw New NotImplementedException("Add SixLabors.ImageSharp or similar")
    End Function
End Class

using IronOcr;

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

    public string ProcessMultiPageTiff(string tiffPath)
    {
        using var input = new OcrInput();
        input.LoadImageFrames(tiffPath); // All frames loaded — no external library needed

        var result = _ocr.Read(input);
        return result.Text; // Pages assembled in order automatically
    }

    public IEnumerable<(int PageNumber, string Text, double Confidence)> ProcessTiffWithPageData(string tiffPath)
    {
        using var input = new OcrInput();
        input.LoadImageFrames(tiffPath);

        var result = _ocr.Read(input);

        foreach (var page in result.Pages)
            yield return (page.PageNumber, page.Text, page.Confidence);
    }
}

Imports IronOcr

Public Class TiffOcrProcessor
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ProcessMultiPageTiff(tiffPath As String) As String
        Using input As New OcrInput()
            input.LoadImageFrames(tiffPath) ' All frames loaded — no external library needed

            Dim result = _ocr.Read(input)
            Return result.Text ' Pages assembled in order automatically
        End Using
    End Function

    Public Iterator Function ProcessTiffWithPageData(tiffPath As String) As IEnumerable(Of (PageNumber As Integer, Text As String, Confidence As Double))
        Using input As New OcrInput()
            input.LoadImageFrames(tiffPath)

            Dim result = _ocr.Read(input)

            For Each page In result.Pages
                Yield (page.PageNumber, page.Text, page.Confidence)
            Next
        End Using
    End Function
End Class

using RapidOcrNet;

public class FormFieldExtractor
{
    private readonly RapidOcrEngine _engine;

    public FormFieldExtractor(string modelDir)
    {
        _engine = new RapidOcrEngine(new RapidOcrOptions
        {
            DetModelPath = Path.Combine(modelDir, "det.onnx"),
            ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
            RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
            KeysPath     = Path.Combine(modelDir, "en_keys.txt")
        });
    }

    // Extract text within a defined region by filtering block coordinates manually
    public string ExtractFieldByRegion(string imagePath, float regionLeft, float regionTop,
                                        float regionRight, float regionBottom)
    {
        var result = _engine.Run(imagePath);

        // Filter blocks whose bounding box intersects the target region
        var blocksInRegion = result.TextBlocks
            .Where(b =>
                b.BoundingBox.Left   < regionRight  &&
                b.BoundingBox.Right  > regionLeft   &&
                b.BoundingBox.Top    < regionBottom &&
                b.BoundingBox.Bottom > regionTop)
            .OrderBy(b => b.BoundingBox.Top)
            .ThenBy(b => b.BoundingBox.Left);

        return string.Join(" ", blocksInRegion.Select(b => b.Text));
    }
}

Imports RapidOcrNet

Public Class FormFieldExtractor
    Private ReadOnly _engine As RapidOcrEngine

    Public Sub New(modelDir As String)
        _engine = New RapidOcrEngine(New RapidOcrOptions With {
            .DetModelPath = Path.Combine(modelDir, "det.onnx"),
            .ClsModelPath = Path.Combine(modelDir, "cls.onnx"),
            .RecModelPath = Path.Combine(modelDir, "rec_en.onnx"),
            .KeysPath = Path.Combine(modelDir, "en_keys.txt")
        })
    End Sub

    ' Extract text within a defined region by filtering block coordinates manually
    Public Function ExtractFieldByRegion(imagePath As String, regionLeft As Single, regionTop As Single,
                                         regionRight As Single, regionBottom As Single) As String
        Dim result = _engine.Run(imagePath)

        ' Filter blocks whose bounding box intersects the target region
        Dim blocksInRegion = result.TextBlocks _
            .Where(Function(b) b.BoundingBox.Left < regionRight AndAlso
                               b.BoundingBox.Right > regionLeft AndAlso
                               b.BoundingBox.Top < regionBottom AndAlso
                               b.BoundingBox.Bottom > regionTop) _
            .OrderBy(Function(b) b.BoundingBox.Top) _
            .ThenBy(Function(b) b.BoundingBox.Left)

        Return String.Join(" ", blocksInRegion.Select(Function(b) b.Text))
    End Function
End Class

using IronOcr;

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

    // Use CropRectangle to OCR only the target region — no post-filter needed
    public string ExtractFieldByRegion(string imagePath, int x, int y, int width, int height)
    {
        var region = new CropRectangle(x, y, width, height);

        using var input = new OcrInput();
        input.LoadImage(imagePath, region);

        return _ocr.Read(input).Text;
    }

    // Extract all fields with their coordinates from a full-page scan
    public IEnumerable<(string Text, int X, int Y, double Confidence)> ExtractAllWords(string imagePath)
    {
        var result = _ocr.Read(imagePath);

        foreach (var page in result.Pages)
            foreach (var word in page.Words)
                yield return (word.Text, word.X, word.Y, word.Confidence);
    }
}

Imports IronOcr

Public Class FormFieldExtractor
    Private ReadOnly _ocr As New IronTesseract()

    ' Use CropRectangle to OCR only the target region — no post-filter needed
    Public Function ExtractFieldByRegion(imagePath As String, x As Integer, y As Integer, width As Integer, height As Integer) As String
        Dim region As New CropRectangle(x, y, width, height)

        Using input As New OcrInput()
            input.LoadImage(imagePath, region)
            Return _ocr.Read(input).Text
        End Using
    End Function

    ' Extract all fields with their coordinates from a full-page scan
    Public Iterator Function ExtractAllWords(imagePath As String) As IEnumerable(Of (Text As String, X As Integer, Y As Integer, Confidence As Double))
        Dim result = _ocr.Read(imagePath)

        For Each page In result.Pages
            For Each word In page.Words
                Yield (word.Text, word.X, word.Y, word.Confidence)
            Next
        Next
    End Function
End Class

<ItemGroup>
  <Content Include="models\**\*.*">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </Content>
</ItemGroup>

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.Spanish;
var result = ocr.Read("spanish-document.jpg");

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.Spanish
Dim result = ocr.Read("spanish-document.jpg")

// Before: manual sort + coordinate extraction
var sorted = result.TextBlocks
    .OrderBy(b => b.BoundingBox.Top)
    .ThenBy(b => b.BoundingBox.Left);

foreach (var block in sorted)
    Console.WriteLine($"{block.Text} at ({block.BoundingBox.Left}, {block.BoundingBox.Top})");

// After: structured access, already in order
foreach (var page in result.Pages)
    foreach (var word in page.Words)
        Console.WriteLine($"{word.Text} at ({word.X}, {word.Y})");

Imports System
Imports System.Linq

' Before: manual sort + coordinate extraction
Dim sorted = result.TextBlocks _
    .OrderBy(Function(b) b.BoundingBox.Top) _
    .ThenBy(Function(b) b.BoundingBox.Left)

For Each block In sorted
    Console.WriteLine($"{block.Text} at ({block.BoundingBox.Left}, {block.BoundingBox.Top})")

' After: structured access, already in order
For Each page In result.Pages
    For Each word In page.Words
        Console.WriteLine($"{word.Text} at ({word.X}, {word.Y})")
    Next
Next

# Find all files that reference RapidOcrNet
grep -r "RapidOcrNet\|RapidOcrEngine\|RapidOcrOptions" --include="*.cs" .

# Find model path configuration
grep -r "DetModelPath\|ClsModelPath\|RecModelPath\|KeysPath" --include="*.cs" .

# Find MSBuild model copy entries
grep -r "det\.onnx\|cls\.onnx\|rec.*\.onnx\|keys\.txt" --include="*.csproj" .

# Find model validation logic
grep -r "ValidateModel\|models/" --include="*.cs" .

# Find ONNX Runtime references
grep -r "OnnxRuntime\|Microsoft\.ML" --include="*.csproj" .

# Find language-switching patterns (multiple engine instances per language)
grep -r "CreateEnglishEngine\|CreateChineseEngine\|rec_en\|ch_rec\|en_keys\|ch_keys" --include="*.cs" .