Umstellung von Aspose.OCR auf IronOCR

Das grundsätzliche Problem

Aspose.OCR verknüpft die Erkennungskonfiguration mit einem Einstellungsobjekt, das erstellt, befüllt und bei jedem Aufruf übergeben werden muss. Modus, Sprache, Filter und Bereichsstrategie sind allesamt Eigenschaften dieses Objekts:

// Aspose.OCR: build a settings object for every recognition call
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.DOCUMENT, // must choose the right mode
    RecognizeSingleLine = false,
    AutoSkew = true
};
var result = api.RecognizeImage("form.jpg", settings);
string text = result.RecognitionText;

// Aspose.OCR: build a settings object for every recognition call
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.DOCUMENT, // must choose the right mode
    RecognizeSingleLine = false,
    AutoSkew = true
};
var result = api.RecognizeImage("form.jpg", settings);
string text = result.RecognitionText;

Imports Aspose.OCR

' Aspose.OCR: build a settings object for every recognition call
Dim api As New AsposeOcr()
Dim settings As New RecognitionSettings With {
    .Language = Language.Eng,
    .DetectAreasMode = DetectAreasMode.DOCUMENT, ' must choose the right mode
    .RecognizeSingleLine = False,
    .AutoSkew = True
}
Dim result = api.RecognizeImage("form.jpg", settings)
Dim text As String = result.RecognitionText

IronOCR verwendet einen einzigen .Read()-Aufruf. Konfigurationen liegen auf der IronTesseract-Instanz, wenn sie benötigt werden, nicht auf einem einzelnen Aufrufobjekt:

// IronOCR: one call, no settings object required
var text = new IronTesseract().Read("form.jpg").Text;

// IronOCR: one call, no settings object required
var text = new IronTesseract().Read("form.jpg").Text;

Imports IronOcr

Dim text As String = New IronTesseract().Read("form.jpg").Text

Schritt 1: Ersetzen des NuGet-Pakets

Aspose.OCR entfernen:

dotnet remove package Aspose.OCR

dotnet remove package Aspose.OCR

Installieren Sie IronOCR über NuGet :

dotnet add package IronOcr

Schritt 2: Namespaces aktualisieren

Ersetzen Sie alle Aspose.OCR-Namespace-Importe:

// Before (Aspose.OCR)
using Aspose.OCR;
using Aspose.OCR.Models;
using Aspose.OCR.Models.PreprocessingFilters;

// After (IronOCR)
using IronOcr;

// Before (Aspose.OCR)
using Aspose.OCR;
using Aspose.OCR.Models;
using Aspose.OCR.Models.PreprocessingFilters;

// After (IronOCR)
using IronOcr;

Imports IronOcr

Schritt 3: Lizenz initialisieren

Entfernen Sie den dateibasierten Lizenzaufruf von Aspose und ersetzen Sie ihn durch den IronOCR Zeichenfolgenschlüssel. Platzieren Sie dies beim Anwendungsstart – einmal pro Prozess, nicht einmal pro Anfrage:

// Remove Aspose license setup
// var license = new Aspose.OCR.License();
// license.SetLicense("Aspose.OCR.lic");

// Add IronOCR license at startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

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

// Remove Aspose license setup
// var license = new Aspose.OCR.License();
// license.SetLicense("Aspose.OCR.lic");

// Add IronOCR license at startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

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

' Remove Aspose license setup
' Dim license As New Aspose.OCR.License()
' license.SetLicense("Aspose.OCR.lic")

' Add IronOCR license at startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

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

Konfiguration der Erkennungseinstellungen

Aspose.OCR zentralisiert das gesamte Erkennungsverhalten in einem RecognitionSettings-Objekt. Sprache, Bereichserkennungsmodus, Einzelzeilen-Flag und Schwellenwert sind dort alle als Eigenschaften hinterlegt. Sie erstellen es für jeden Dokumenttyp oder jedes Aufrufmuster neu.

Aspose.OCR-Ansatz:

// Configuring recognition settings for a structured form
var api = new AsposeOcr();

var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.DOCUMENT,
    RecognizeSingleLine = false,
    AutoSkew = true,
    RecognitionAreas = new List<Rectangle>
    {
        new Rectangle(0, 0, 800, 100)  // header zone
    }
};

var result = api.RecognizeImage("structured-form.jpg", settings);
Console.WriteLine(result.RecognitionText);

// Configuring recognition settings for a structured form
var api = new AsposeOcr();

var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.DOCUMENT,
    RecognizeSingleLine = false,
    AutoSkew = true,
    RecognitionAreas = new List<Rectangle>
    {
        new Rectangle(0, 0, 800, 100)  // header zone
    }
};

var result = api.RecognizeImage("structured-form.jpg", settings);
Console.WriteLine(result.RecognitionText);

Imports System
Imports System.Collections.Generic
Imports AsposeOcr

' Configuring recognition settings for a structured form
Dim api As New AsposeOcr()

Dim settings As New RecognitionSettings With {
    .Language = Language.Eng,
    .DetectAreasMode = DetectAreasMode.DOCUMENT,
    .RecognizeSingleLine = False,
    .AutoSkew = True,
    .RecognitionAreas = New List(Of Rectangle) From {
        New Rectangle(0, 0, 800, 100)  ' header zone
    }
}

Dim result = api.RecognizeImage("structured-form.jpg", settings)
Console.WriteLine(result.RecognitionText)

IronOCR Ansatz:

// Recognition behavior configured once on the IronTesseract instance
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;

// Region targeting replaces RecognitionAreas in RecognitionSettings
var headerRegion = new CropRectangle(0, 0, 800, 100);
using var input = new OcrInput();
input.LoadImage("structured-form.jpg", headerRegion);

var result = ocr.Read(input);
Console.WriteLine(result.Text);

// Recognition behavior configured once on the IronTesseract instance
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;

// Region targeting replaces RecognitionAreas in RecognitionSettings
var headerRegion = new CropRectangle(0, 0, 800, 100);
using var input = new OcrInput();
input.LoadImage("structured-form.jpg", headerRegion);

var result = ocr.Read(input);
Console.WriteLine(result.Text);

Imports IronOcr

' Recognition behavior configured once on the IronTesseract instance
Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.English

' Region targeting replaces RecognitionAreas in RecognitionSettings
Dim headerRegion As New CropRectangle(0, 0, 800, 100)
Using input As New OcrInput()
    input.LoadImage("structured-form.jpg", headerRegion)

    Dim result = ocr.Read(input)
    Console.WriteLine(result.Text)
End Using

Es gibt kein Einstellungsobjekt, das pro Aufruf erstellt werden muss. Sprache geht auf die IronTesseract-Instanz; Die Zielregion geht auf OcrInput zur Ladezeit. Die DetectAreasMode- und RecognizeSingleLine-Entscheidungen werden vom Motor automatisch gehandhabt. Eine detaillierte Anleitung zur regionsbasierten OCR finden Sie im Leitfaden zur regionsbasierten OCR .

Bereichserkennungsmodus-Migration

Aspose.OCR erfordert, dass Sie vor jedem Erkennungsaufruf einen DetectAreasMode-Wert auswählen. COMBINE führt Text aus verschiedenen Layoutregionen zusammen, DOCUMENT behandelt das Bild als Standarddokument, TABLE optimiert für Rasterlayouts. Die Wahl des falschen Modus für den Dokumenttyp führt zu falsch ausgerichteten oder fehlenden Ausgaben.

Aspose.OCR-Ansatz:

// Three separate calls with different modes for different document types
var api = new AsposeOcr();

// For a document with mixed prose and table content
var docSettings = new RecognitionSettings
{
    DetectAreasMode = DetectAreasMode.COMBINE,
    Language = Language.Eng
};

// For a pure tabular document
var tableSettings = new RecognitionSettings
{
    DetectAreasMode = DetectAreasMode.TABLE,
    Language = Language.Eng
};

// For a single-column text document
var linearSettings = new RecognitionSettings
{
    DetectAreasMode = DetectAreasMode.DOCUMENT,
    Language = Language.Eng
};

string mixedResult = api.RecognizeImage("mixed-layout.jpg", docSettings).RecognitionText;
string tableResult = api.RecognizeImage("data-table.jpg", tableSettings).RecognitionText;
string linearResult = api.RecognizeImage("text-document.jpg", linearSettings).RecognitionText;

// Three separate calls with different modes for different document types
var api = new AsposeOcr();

// For a document with mixed prose and table content
var docSettings = new RecognitionSettings
{
    DetectAreasMode = DetectAreasMode.COMBINE,
    Language = Language.Eng
};

// For a pure tabular document
var tableSettings = new RecognitionSettings
{
    DetectAreasMode = DetectAreasMode.TABLE,
    Language = Language.Eng
};

// For a single-column text document
var linearSettings = new RecognitionSettings
{
    DetectAreasMode = DetectAreasMode.DOCUMENT,
    Language = Language.Eng
};

string mixedResult = api.RecognizeImage("mixed-layout.jpg", docSettings).RecognitionText;
string tableResult = api.RecognizeImage("data-table.jpg", tableSettings).RecognitionText;
string linearResult = api.RecognizeImage("text-document.jpg", linearSettings).RecognitionText;

Imports AsposeOcr

' Three separate calls with different modes for different document types
Dim api As New AsposeOcr()

' For a document with mixed prose and table content
Dim docSettings As New RecognitionSettings With {
    .DetectAreasMode = DetectAreasMode.COMBINE,
    .Language = Language.Eng
}

' For a pure tabular document
Dim tableSettings As New RecognitionSettings With {
    .DetectAreasMode = DetectAreasMode.TABLE,
    .Language = Language.Eng
}

' For a single-column text document
Dim linearSettings As New RecognitionSettings With {
    .DetectAreasMode = DetectAreasMode.DOCUMENT,
    .Language = Language.Eng
}

Dim mixedResult As String = api.RecognizeImage("mixed-layout.jpg", docSettings).RecognitionText
Dim tableResult As String = api.RecognizeImage("data-table.jpg", tableSettings).RecognitionText
Dim linearResult As String = api.RecognizeImage("text-document.jpg", linearSettings).RecognitionText

IronOCR Ansatz:

// Single API surface handles all layout types automatically
var ocr = new IronTesseract();

// Same code path for every document type
var mixedResult = ocr.Read("mixed-layout.jpg").Text;
var tableResult = ocr.Read("data-table.jpg").Text;
var linearResult = ocr.Read("text-document.jpg").Text;

// For table documents, structured data is immediately available
var result = ocr.Read("data-table.jpg");
foreach (var page in result.Pages)
{
    foreach (var paragraph in page.Paragraphs)
    {
        Console.WriteLine($"Block at ({paragraph.X}, {paragraph.Y}): {paragraph.Text}");
    }
}

// Single API surface handles all layout types automatically
var ocr = new IronTesseract();

// Same code path for every document type
var mixedResult = ocr.Read("mixed-layout.jpg").Text;
var tableResult = ocr.Read("data-table.jpg").Text;
var linearResult = ocr.Read("text-document.jpg").Text;

// For table documents, structured data is immediately available
var result = ocr.Read("data-table.jpg");
foreach (var page in result.Pages)
{
    foreach (var paragraph in page.Paragraphs)
    {
        Console.WriteLine($"Block at ({paragraph.X}, {paragraph.Y}): {paragraph.Text}");
    }
}

Imports System

' Single API surface handles all layout types automatically
Dim ocr As New IronTesseract()

' Same code path for every document type
Dim mixedResult As String = ocr.Read("mixed-layout.jpg").Text
Dim tableResult As String = ocr.Read("data-table.jpg").Text
Dim linearResult As String = ocr.Read("text-document.jpg").Text

' For table documents, structured data is immediately available
Dim result = ocr.Read("data-table.jpg")
For Each page In result.Pages
    For Each paragraph In page.Paragraphs
        Console.WriteLine($"Block at ({paragraph.X}, {paragraph.Y}): {paragraph.Text}")
    Next
Next

IronOCR macht die Entscheidung über die Modusauswahl komplett überflüssig. Der Motor analysiert Layouts und stellt das Ergebnis durch die Pages, Paragraphs, Lines und Words-Hierarchie bereit. Der Leitfaden zu den Leseergebnissen beschreibt, wie man im vollständigen strukturierten Ergebnismodell für die Dokumentenlayoutanalyse navigiert. Für tabellenspezifische Extraktionsmuster siehe die Anleitung zum Lesen von Tabellen .

Stapelerkennung mit konfessionsbasierter Filterung

Aspose.OCR-Batch-Workflows akkumulieren RecognitionResult-Objekte in einer Liste. Vertrauensfilterung erfordert das Durchlaufen dieser Liste und das Berechnen des Durchschnitts pro Region, bevor ein Ergebnis angenommen wird. Die Liste muss explizit verwaltet und an SaveMultipageDocument übergeben werden, wenn Sie mehrere Seiten als eine einzelne Datei ausgeben möchten.

Aspose.OCR-Ansatz:

// Batch recognition with confidence filtering before output
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.DOCUMENT
};

string[] documentPaths = Directory.GetFiles("invoice-archive", "*.jpg");
var acceptedResults = new List<RecognitionResult>();
var rejectedPaths = new List<string>();

foreach (var path in documentPaths)
{
    var result = api.RecognizeImage(path, settings);

    // Confidence is an array of per-region values — must average manually
    float avgConfidence = result.RecognitionAreasConfidence != null
        ? result.RecognitionAreasConfidence.Average()
        : 0f;

    if (avgConfidence >= 0.70f)
    {
        acceptedResults.Add(result);
    }
    else
    {
        rejectedPaths.Add(path);
        Console.WriteLine($"Rejected: {path} ({avgConfidence:P0} confidence)");
    }
}

// Save accepted pages as a single searchable PDF
if (acceptedResults.Any())
{
    api.SaveMultipageDocument("high-confidence-invoices.pdf",
        SaveFormat.Pdf, acceptedResults);
}

Console.WriteLine($"Accepted: {acceptedResults.Count}, Rejected: {rejectedPaths.Count}");

// Batch recognition with confidence filtering before output
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.DOCUMENT
};

string[] documentPaths = Directory.GetFiles("invoice-archive", "*.jpg");
var acceptedResults = new List<RecognitionResult>();
var rejectedPaths = new List<string>();

foreach (var path in documentPaths)
{
    var result = api.RecognizeImage(path, settings);

    // Confidence is an array of per-region values — must average manually
    float avgConfidence = result.RecognitionAreasConfidence != null
        ? result.RecognitionAreasConfidence.Average()
        : 0f;

    if (avgConfidence >= 0.70f)
    {
        acceptedResults.Add(result);
    }
    else
    {
        rejectedPaths.Add(path);
        Console.WriteLine($"Rejected: {path} ({avgConfidence:P0} confidence)");
    }
}

// Save accepted pages as a single searchable PDF
if (acceptedResults.Any())
{
    api.SaveMultipageDocument("high-confidence-invoices.pdf",
        SaveFormat.Pdf, acceptedResults);
}

Console.WriteLine($"Accepted: {acceptedResults.Count}, Rejected: {rejectedPaths.Count}");

Imports System
Imports System.IO
Imports System.Linq
Imports Aspose.OCR

' Batch recognition with confidence filtering before output
Dim api As New AsposeOcr()
Dim settings As New RecognitionSettings With {
    .Language = Language.Eng,
    .DetectAreasMode = DetectAreasMode.DOCUMENT
}

Dim documentPaths As String() = Directory.GetFiles("invoice-archive", "*.jpg")
Dim acceptedResults As New List(Of RecognitionResult)()
Dim rejectedPaths As New List(Of String)()

For Each path In documentPaths
    Dim result = api.RecognizeImage(path, settings)

    ' Confidence is an array of per-region values — must average manually
    Dim avgConfidence As Single = If(result.RecognitionAreasConfidence IsNot Nothing,
                                     result.RecognitionAreasConfidence.Average(),
                                     0.0F)

    If avgConfidence >= 0.70F Then
        acceptedResults.Add(result)
    Else
        rejectedPaths.Add(path)
        Console.WriteLine($"Rejected: {path} ({avgConfidence:P0} confidence)")
    End If
Next

' Save accepted pages as a single searchable PDF
If acceptedResults.Any() Then
    api.SaveMultipageDocument("high-confidence-invoices.pdf",
                              SaveFormat.Pdf, acceptedResults)
End If

Console.WriteLine($"Accepted: {acceptedResults.Count}, Rejected: {rejectedPaths.Count}")

IronOCR Ansatz:

// Batch recognition with confidence filtering using unified result model
var ocr = new IronTesseract();
string[] documentPaths = Directory.GetFiles("invoice-archive", "*.jpg");

var acceptedResults = new List<OcrResult>();
var rejectedPaths = new List<string>();

foreach (var path in documentPaths)
{
    var result = ocr.Read(path);

    // Single confidence value — no averaging required
    if (result.Confidence >= 70.0)
    {
        acceptedResults.Add(result);
    }
    else
    {
        rejectedPaths.Add(path);
        Console.WriteLine($"Rejected: {path} ({result.Confidence:F1}% confidence)");
    }
}

// Save accepted pages — each result becomes a page in the output PDF
if (acceptedResults.Any())
{
    using var outputInput = new OcrInput();
    foreach (var path in documentPaths
        .Where(p => !rejectedPaths.Contains(p)))
    {
        outputInput.LoadImage(path);
    }
    var combined = ocr.Read(outputInput);
    combined.SaveAsSearchablePdf("high-confidence-invoices.pdf");
}

Console.WriteLine($"Accepted: {acceptedResults.Count}, Rejected: {rejectedPaths.Count}");

// Batch recognition with confidence filtering using unified result model
var ocr = new IronTesseract();
string[] documentPaths = Directory.GetFiles("invoice-archive", "*.jpg");

var acceptedResults = new List<OcrResult>();
var rejectedPaths = new List<string>();

foreach (var path in documentPaths)
{
    var result = ocr.Read(path);

    // Single confidence value — no averaging required
    if (result.Confidence >= 70.0)
    {
        acceptedResults.Add(result);
    }
    else
    {
        rejectedPaths.Add(path);
        Console.WriteLine($"Rejected: {path} ({result.Confidence:F1}% confidence)");
    }
}

// Save accepted pages — each result becomes a page in the output PDF
if (acceptedResults.Any())
{
    using var outputInput = new OcrInput();
    foreach (var path in documentPaths
        .Where(p => !rejectedPaths.Contains(p)))
    {
        outputInput.LoadImage(path);
    }
    var combined = ocr.Read(outputInput);
    combined.SaveAsSearchablePdf("high-confidence-invoices.pdf");
}

Console.WriteLine($"Accepted: {acceptedResults.Count}, Rejected: {rejectedPaths.Count}");

Imports IronTesseract
Imports System.IO
Imports System.Linq

' Batch recognition with confidence filtering using unified result model
Dim ocr As New IronTesseract()
Dim documentPaths As String() = Directory.GetFiles("invoice-archive", "*.jpg")

Dim acceptedResults As New List(Of OcrResult)()
Dim rejectedPaths As New List(Of String)()

For Each path In documentPaths
    Dim result = ocr.Read(path)

    ' Single confidence value — no averaging required
    If result.Confidence >= 70.0 Then
        acceptedResults.Add(result)
    Else
        rejectedPaths.Add(path)
        Console.WriteLine($"Rejected: {path} ({result.Confidence:F1}% confidence)")
    End If
Next

' Save accepted pages — each result becomes a page in the output PDF
If acceptedResults.Any() Then
    Using outputInput As New OcrInput()
        For Each path In documentPaths.Where(Function(p) Not rejectedPaths.Contains(p))
            outputInput.LoadImage(path)
        Next
        Dim combined = ocr.Read(outputInput)
        combined.SaveAsSearchablePdf("high-confidence-invoices.pdf")
    End Using
End If

Console.WriteLine($"Accepted: {acceptedResults.Count}, Rejected: {rejectedPaths.Count}")

result.Confidence ist ein einfaches double im Bereich von 0 bis 100. Das Aspose RecognitionAreasConfidence-Array-Durchschnitt gibt einen float in einem Bereich zurück, der von der Version abhängt — der Vergleichsschwellenwert muss während der Migration angepasst werden. Die Konfidenzwerte dienen als Leitfaden für die Konfidenzwerte pro Wort, pro Zeile und pro Seite in Dokumentenvalidierungs-Workflows. Für Batchverarbeitungsmuster mit hohem Datenvolumen siehe das Beispiel zur Multithreading-Verarbeitung .

Strukturierte Ausgabeverarbeitung

Aspose.OCR gibt strukturierte Daten über SaveMultipageDocument mit formatspezifischen SaveFormat-Enum-Werten aus. JSON-Ausgabe schreibt eine maschinenlesbare Datei; XML-Ausgabe schreibt eine annotierte Dokumentdatei. Der Zugriff auf die rohen strukturierten Daten — Wortpositionen, Zeilengrenzen — erfordert das Durchlaufen von RecognitionAreasRectangles, das Geometrie auf Bereichsebene und nicht auf Wortebene zurückgibt.

Aspose.OCR-Ansatz:

// Structured output: JSON and XML via SaveMultipageDocument
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.COMBINE
};

var results = new List<RecognitionResult>();
foreach (var path in new[] { "page1.jpg", "page2.jpg", "page3.jpg" })
{
    results.Add(api.RecognizeImage(path, settings));
}

// Export as JSON
api.SaveMultipageDocument("output.json", SaveFormat.Json, results);

// Export as XML
api.SaveMultipageDocument("output.xml", SaveFormat.Xml, results);

// Accessing area-level geometry (not word-level)
foreach (var result in results)
{
    var areas = result.RecognitionAreasRectangles;
    if (areas != null)
    {
        foreach (var area in areas)
        {
            Console.WriteLine($"Area at ({area.X},{area.Y}): {area.Width}x{area.Height}");
        }
    }
    // No direct word-level collection with individual confidence values
}

// Structured output: JSON and XML via SaveMultipageDocument
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    DetectAreasMode = DetectAreasMode.COMBINE
};

var results = new List<RecognitionResult>();
foreach (var path in new[] { "page1.jpg", "page2.jpg", "page3.jpg" })
{
    results.Add(api.RecognizeImage(path, settings));
}

// Export as JSON
api.SaveMultipageDocument("output.json", SaveFormat.Json, results);

// Export as XML
api.SaveMultipageDocument("output.xml", SaveFormat.Xml, results);

// Accessing area-level geometry (not word-level)
foreach (var result in results)
{
    var areas = result.RecognitionAreasRectangles;
    if (areas != null)
    {
        foreach (var area in areas)
        {
            Console.WriteLine($"Area at ({area.X},{area.Y}): {area.Width}x{area.Height}");
        }
    }
    // No direct word-level collection with individual confidence values
}

Imports System
Imports System.Collections.Generic
Imports AsposeOcr

' Structured output: JSON and XML via SaveMultipageDocument
Dim api As New AsposeOcr()
Dim settings As New RecognitionSettings With {
    .Language = Language.Eng,
    .DetectAreasMode = DetectAreasMode.COMBINE
}

Dim results As New List(Of RecognitionResult)()
For Each path In New String() {"page1.jpg", "page2.jpg", "page3.jpg"}
    results.Add(api.RecognizeImage(path, settings))
Next

' Export as JSON
api.SaveMultipageDocument("output.json", SaveFormat.Json, results)

' Export as XML
api.SaveMultipageDocument("output.xml", SaveFormat.Xml, results)

' Accessing area-level geometry (not word-level)
For Each result In results
    Dim areas = result.RecognitionAreasRectangles
    If areas IsNot Nothing Then
        For Each area In areas
            Console.WriteLine($"Area at ({area.X},{area.Y}): {area.Width}x{area.Height}")
        Next
    End If
    ' No direct word-level collection with individual confidence values
Next

IronOCR Ansatz:

// Structured output: navigate a rich result object model
var ocr = new IronTesseract();

using var input = new OcrInput();
input.LoadImage("page1.jpg");
input.LoadImage("page2.jpg");
input.LoadImage("page3.jpg");

var result = ocr.Read(input);

// Export as searchable PDF (preserves layout)
result.SaveAsSearchablePdf("output.pdf");

// Export as hOCR (XHTML with bounding box coordinates — feeds downstream tools)
result.SaveAsHocrFile("output.hocr");

// Word-level structured access — direct collection, no indirection
foreach (var page in result.Pages)
{
    Console.WriteLine($"Page {page.PageNumber}: {page.Words.Length} words, " +
                      $"{page.Confidence:F1}% confidence");

    foreach (var word in page.Words)
    {
        Console.WriteLine($"  '{word.Text}' at ({word.X},{word.Y}) " +
                          $"size {word.Width}x{word.Height} — {word.Confidence:F1}%");
    }
}

// Paragraph-level layout for document structure analysis
foreach (var paragraph in result.Pages[0].Paragraphs)
{
    Console.WriteLine($"Paragraph at ({paragraph.X},{paragraph.Y}): {paragraph.Text}");
}

// Structured output: navigate a rich result object model
var ocr = new IronTesseract();

using var input = new OcrInput();
input.LoadImage("page1.jpg");
input.LoadImage("page2.jpg");
input.LoadImage("page3.jpg");

var result = ocr.Read(input);

// Export as searchable PDF (preserves layout)
result.SaveAsSearchablePdf("output.pdf");

// Export as hOCR (XHTML with bounding box coordinates — feeds downstream tools)
result.SaveAsHocrFile("output.hocr");

// Word-level structured access — direct collection, no indirection
foreach (var page in result.Pages)
{
    Console.WriteLine($"Page {page.PageNumber}: {page.Words.Length} words, " +
                      $"{page.Confidence:F1}% confidence");

    foreach (var word in page.Words)
    {
        Console.WriteLine($"  '{word.Text}' at ({word.X},{word.Y}) " +
                          $"size {word.Width}x{word.Height} — {word.Confidence:F1}%");
    }
}

// Paragraph-level layout for document structure analysis
foreach (var paragraph in result.Pages[0].Paragraphs)
{
    Console.WriteLine($"Paragraph at ({paragraph.X},{paragraph.Y}): {paragraph.Text}");
}

Imports IronTesseract

' Structured output: navigate a rich result object model
Dim ocr As New IronTesseract()

Using input As New OcrInput()
    input.LoadImage("page1.jpg")
    input.LoadImage("page2.jpg")
    input.LoadImage("page3.jpg")

    Dim result = ocr.Read(input)

    ' Export as searchable PDF (preserves layout)
    result.SaveAsSearchablePdf("output.pdf")

    ' Export as hOCR (XHTML with bounding box coordinates — feeds downstream tools)
    result.SaveAsHocrFile("output.hocr")

    ' Word-level structured access — direct collection, no indirection
    For Each page In result.Pages
        Console.WriteLine($"Page {page.PageNumber}: {page.Words.Length} words, " &
                          $"{page.Confidence:F1}% confidence")

        For Each word In page.Words
            Console.WriteLine($"  '{word.Text}' at ({word.X},{word.Y}) " &
                              $"size {word.Width}x{word.Height} — {word.Confidence:F1}%")
        Next
    Next

    ' Paragraph-level layout for document structure analysis
    For Each paragraph In result.Pages(0).Paragraphs
        Console.WriteLine($"Paragraph at ({paragraph.X},{paragraph.Y}): {paragraph.Text}")
    Next
End Using

IronOCR stellt wortbezogene Daten als direkte Words-Sammlung auf jeder Seite bereit, mit individuellen Confidence-Werten pro Wort. Aspose.OCR's RecognitionAreasRectangles bietet Bereichsgeometrie ohne detaillierte Vertrauensauflösung auf Wortebene. Der hOCR-Export erzeugt XHTML, das mit Tools kompatibel ist, die Ausgaben mit Begrenzungsrahmen-Annotationen verarbeiten – Einzelheiten zum Format finden Sie im hOCR-Exportleitfaden . Für das vollständige strukturierte Ergebnismodell dokumentiert die OcrResult-API-Referenz jede Eigenschaft auf OcrResult.Page, OcrResult.Paragraph, OcrResult.Line und OcrResult.Word.

Problem 1: DetectAreasMode hat kein direktes Äquivalent.

Aspose.OCR: Der Code setzt settings.DetectAreasMode = DetectAreasMode.TABLE oder DetectAreasMode.COMBINE und erwartet spezifisches Layoutverhalten. Das Entfernen des Enums wirft die Frage auf, wie IronOCR mit demselben Layout umgeht.

Lösung: Entfernen Sie die Aufzählung vollständig.IronOCR führt automatisch eine Layoutanalyse durch. Wenn Sie die erkannte Layoutstruktur inspizieren müssen, navigieren Sie result.Pages[n].Paragraphs — jeder Absatz enthält ein begrenzendes X, Y, Breite, Höhe Kästchen und den darin enthaltenen Text. Für die explizite Tabellenextraktion siehe die Anleitung zum Einlesen von Tabellen :

// No mode to set — read directly and inspect the structure
var result = new IronTesseract().Read("data-table.jpg");
foreach (var paragraph in result.Pages[0].Paragraphs)
{
    Console.WriteLine($"Block ({paragraph.X},{paragraph.Y}): {paragraph.Text}");
}

// No mode to set — read directly and inspect the structure
var result = new IronTesseract().Read("data-table.jpg");
foreach (var paragraph in result.Pages[0].Paragraphs)
{
    Console.WriteLine($"Block ({paragraph.X},{paragraph.Y}): {paragraph.Text}");
}

Imports IronTesseract

Dim result = New IronTesseract().Read("data-table.jpg")
For Each paragraph In result.Pages(0).Paragraphs
    Console.WriteLine($"Block ({paragraph.X},{paragraph.Y}): {paragraph.Text}")
Next

Problem 2: Diskrepanz zwischen Konfidenzschwellenwert für Erkennungsbereiche

Aspose.OCR: Bestehender Code vergleicht result.RecognitionAreasConfidence.Average() gegen einen Schwellenwert wie 0.75f. IronOCR's result.Confidence befindet sich auf einer anderen Skala.

Lösung: result.Confidence ist ein Prozentsatz von 0–100. Multiplizieren Sie Ihren Aspose-Schwellenwert mit 100, um zu konvertieren: 0.75f wird zu 75.0. Aktualisieren Sie anschließend die gesamte Vergleichslogik:

// Aspose.OCR threshold pattern
// if (result.RecognitionAreasConfidence.Average() >= 0.75f)

//IronOCR equivalent — multiply old threshold by 100
var result = new IronTesseract().Read("document.jpg");
if (result.Confidence >= 75.0)
{
    Console.WriteLine($"High confidence result: {result.Text}");
}

// Aspose.OCR threshold pattern
// if (result.RecognitionAreasConfidence.Average() >= 0.75f)

//IronOCR equivalent — multiply old threshold by 100
var result = new IronTesseract().Read("document.jpg");
if (result.Confidence >= 75.0)
{
    Console.WriteLine($"High confidence result: {result.Text}");
}

Imports IronOcr

Dim result = New IronTesseract().Read("document.jpg")
If result.Confidence >= 75.0 Then
    Console.WriteLine($"High confidence result: {result.Text}")
End If

Problem 3: SaveMultipageDocument JSON/XML-Ausgabe hat keine direkte Methode

Aspose.OCR: api.SaveMultipageDocument("out.json", SaveFormat.Json, results) schreibt eine JSON-Datei mit Erkennungsmetadaten. Teams, die diese Ausgabe weiterverarbeiten, müssen das Äquivalent finden.

Lösung:IronOCR verfügt nicht über eine SaveFormat.Json-äquivalente Methode. Der Ersatz ist, result.Pages zu navigieren und mit System.Text.Json zu serialisieren. Dies gibt Ihnen die volle Kontrolle über das Schema:

using var input = new OcrInput();
input.LoadImage("document.jpg");
var result = new IronTesseract().Read(input);

// Build your own structured JSON from the result model
var pageData = result.Pages.Select(p => new
{
    PageNumber = p.PageNumber,
    Confidence = p.Confidence,
    Text = p.Text,
    Words = p.Words.Select(w => new
    {
        Text = w.Text,
        X = w.X,
        Y = w.Y,
        Width = w.Width,
        Height = w.Height,
        Confidence = w.Confidence
    }).ToArray()
}).ToArray();

File.WriteAllText("output.json",
    System.Text.Json.JsonSerializer.Serialize(pageData,
        new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));

using var input = new OcrInput();
input.LoadImage("document.jpg");
var result = new IronTesseract().Read(input);

// Build your own structured JSON from the result model
var pageData = result.Pages.Select(p => new
{
    PageNumber = p.PageNumber,
    Confidence = p.Confidence,
    Text = p.Text,
    Words = p.Words.Select(w => new
    {
        Text = w.Text,
        X = w.X,
        Y = w.Y,
        Width = w.Width,
        Height = w.Height,
        Confidence = w.Confidence
    }).ToArray()
}).ToArray();

File.WriteAllText("output.json",
    System.Text.Json.JsonSerializer.Serialize(pageData,
        new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));

Imports IronOcr
Imports System.IO
Imports System.Text.Json

Using input As New OcrInput()
    input.LoadImage("document.jpg")
    Dim result = New IronTesseract().Read(input)

    ' Build your own structured JSON from the result model
    Dim pageData = result.Pages.Select(Function(p) New With {
        .PageNumber = p.PageNumber,
        .Confidence = p.Confidence,
        .Text = p.Text,
        .Words = p.Words.Select(Function(w) New With {
            .Text = w.Text,
            .X = w.X,
            .Y = w.Y,
            .Width = w.Width,
            .Height = w.Height,
            .Confidence = w.Confidence
        }).ToArray()
    }).ToArray()

    File.WriteAllText("output.json",
        JsonSerializer.Serialize(pageData,
            New JsonSerializerOptions With {.WriteIndented = True}))
End Using

Für XHTML-Ausgabe mit eingebetteten Koordinaten, die nachgelagerte Tools analysieren können, ist result.SaveAsHocrFile("output.hocr") das näherliegende semantische Äquivalent.

Problem 4: DocumentRecognitionSettings.StartPage verwendet einen 0-basierten Index

Aspose.OCR: DocumentRecognitionSettings.StartPage = 2 bedeutet die dritte Seite (0-basiert). Dies ist der häufigste Off-by-One-Fehler bei Aspose-zu-IronOCR-Migrationen.

Lösung:IronOCR verwendet durchgehend eine 1-basierte Seitenindizierung. Addieren Sie 1 zu jedem StartPage-Wert und berechnen Sie die Endseite entsprechend neu. Schreiben Sie einen gezielten Test anhand einer bekannten mehrseitigen PDF-Datei, um dies vor der Produktion zu erkennen:

// Aspose.OCR: StartPage = 2 means the 3rd page (0-based)
// var settings = new DocumentRecognitionSettings { StartPage = 2, PagesNumber = 3 };

// IronOCR: page 3 is index 3 (1-based), range of 3 ends at page 5
using var input = new OcrInput();
input.LoadPdfPages("document.pdf", 3, 5);
var result = new IronTesseract().Read(input);

// Aspose.OCR: StartPage = 2 means the 3rd page (0-based)
// var settings = new DocumentRecognitionSettings { StartPage = 2, PagesNumber = 3 };

// IronOCR: page 3 is index 3 (1-based), range of 3 ends at page 5
using var input = new OcrInput();
input.LoadPdfPages("document.pdf", 3, 5);
var result = new IronTesseract().Read(input);

Imports IronOcr

' Aspose.OCR: StartPage = 2 means the 3rd page (0-based)
' Dim settings As New DocumentRecognitionSettings With {.StartPage = 2, .PagesNumber = 3}

' IronOCR: page 3 is index 3 (1-based), range of 3 ends at page 5
Using input As New OcrInput()
    input.LoadPdfPages("document.pdf", 3, 5)
    Dim result = New IronTesseract().Read(input)
End Using

Problem 5: RecognizeSingleLine hat kein direktes Flag

Aspose.OCR: settings.RecognizeSingleLine = true weist den Motor an, das gesamte Bild als einzelne Textzeile zu behandeln. Dies wird für die Erkennung von Etiketten, den Feldauszug und andere Festformat-Eingaben verwendet.

Lösung: Verwenden Sie eine CropRectangle, um die Textzeile präzise zu isolieren, was verhindert, dass der Motor vollständige Layout-Erkennung auf einem Einzelzeilenbild durchführt. Für maschinenlesbare Zonen oder Etikettenformate beschreibt der Leitfaden zum Lesen spezifischer Dokumente das jeweils geeignete Vorgehen:

// Aspose.OCR: single-line flag
// var settings = new RecognitionSettings { RecognizeSingleLine = true };

// IronOCR: crop to the line region — layout detection skips automatically
var lineRegion = new CropRectangle(10, 45, 600, 30); // x, y, width, height
using var input = new OcrInput();
input.LoadImage("label.jpg", lineRegion);
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text.Trim());

// Aspose.OCR: single-line flag
// var settings = new RecognitionSettings { RecognizeSingleLine = true };

// IronOCR: crop to the line region — layout detection skips automatically
var lineRegion = new CropRectangle(10, 45, 600, 30); // x, y, width, height
using var input = new OcrInput();
input.LoadImage("label.jpg", lineRegion);
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text.Trim());

Imports IronOcr

Dim lineRegion As New CropRectangle(10, 45, 600, 30) ' x, y, width, height
Using input As New OcrInput()
    input.LoadImage("label.jpg", lineRegion)
    Dim result = New IronTesseract().Read(input)
    Console.WriteLine(result.Text.Trim())
End Using

Problem 6: Pro-Thread Aspose.OCR Instanzen Nicht Erforderlich

Aspose.OCR: Die Dokumentation empfiehlt, für jeden Thread eine neue AsposeOcr() Instanz zu erstellen, um Thread-Sicherheitsprobleme bei der parallelen Verarbeitung zu vermeiden. Bestehender Code erstellt Instanzen innerhalb von Parallel.ForEach-Lambdas.

Lösung: IronTesseract ist threadsicher. Eine einzelne Instanz verarbeitet parallele Arbeitslasten. Entfernen Sie die Instanziierung pro Thread und teilen Sie eine Instanz:

// Aspose.OCR: per-thread instance due to thread-safety concerns
// Parallel.ForEach(paths, path => { var api = new AsposeOcr(); ... });

// IronOCR: single shared instance, fully thread-safe
var ocr = new IronTesseract();

Parallel.ForEach(documentPaths, path =>
{
    var result = ocr.Read(path);
    Console.WriteLine($"{Path.GetFileName(path)}: {result.Confidence:F1}%");
});

// Aspose.OCR: per-thread instance due to thread-safety concerns
// Parallel.ForEach(paths, path => { var api = new AsposeOcr(); ... });

// IronOCR: single shared instance, fully thread-safe
var ocr = new IronTesseract();

Parallel.ForEach(documentPaths, path =>
{
    var result = ocr.Read(path);
    Console.WriteLine($"{Path.GetFileName(path)}: {result.Confidence:F1}%");
});

Imports System.IO
Imports IronOcr
Imports System.Threading.Tasks

Dim ocr As New IronTesseract()

Parallel.ForEach(documentPaths, Sub(path)
    Dim result = ocr.Read(path)
    Console.WriteLine($"{Path.GetFileName(path)}: {result.Confidence:F1}%")
End Sub)

Vor der Migration anfallende Aufgaben

Prüfen Sie alle Aspose.OCR-Verweise im Quellcode:

grep -rn "using Aspose.OCR" --include="*.cs" .
grep -rn "AsposeOcr\|RecognitionSettings\|DocumentRecognitionSettings" --include="*.cs" .
grep -rn "DetectAreasMode\|SaveFormat\|RecognitionResult" --include="*.cs" .
grep -rn "RecognitionAreasConfidence\|RecognitionText\|RecognizePdf" --include="*.cs" .
grep -rn "PreprocessingFilter\|SaveMultipageDocument" --include="*.cs" .
grep -rn "Aspose.OCR.License\|SetLicense" --include="*.cs" .

grep -rn "using Aspose.OCR" --include="*.cs" .
grep -rn "AsposeOcr\|RecognitionSettings\|DocumentRecognitionSettings" --include="*.cs" .
grep -rn "DetectAreasMode\|SaveFormat\|RecognitionResult" --include="*.cs" .
grep -rn "RecognitionAreasConfidence\|RecognitionText\|RecognizePdf" --include="*.cs" .
grep -rn "PreprocessingFilter\|SaveMultipageDocument" --include="*.cs" .
grep -rn "Aspose.OCR.License\|SetLicense" --include="*.cs" .

Dokumentieren Sie jedes Vorkommen nach Kategorie: Erkennungsaufrufe, Einstellungsobjekte, Vorverarbeitungspipelines, Ausgabeaufrufe und Lizenzinitialisierung. Notieren Sie alle DetectAreasMode-Werte im Einsatz — diese bestimmen den Layout-Migrationspfad. Erfassen Sie alle SaveFormat-Enum-Werte — jedes Nicht-PDF-Format benötigt den benutzerdefinierten Serialisierungsansatz aus Problem 3 oben.

Code-Migration

1. Entfernen Sie das Aspose.OCR-NuGet-Paket aus allen Projekten in der Lösung
2. Installieren Sie IronOcr-NuGet-Paket in allen Projekten
3. Ersetze using Aspose.OCR; und using Aspose.OCR.Models; durch using IronOcr;
4. Ersetze new Aspose.OCR.License().SetLicense("file.lic") mit IronOcr.License.LicenseKey = "key" beim App-Start
5. Ersetze new AsposeOcr() mit new IronTesseract()
6. Entfernen Sie alle RecognitionSettings und DocumentRecognitionSettings-Konstruktionsblöcke
7. Entfernen Sie alle DetectAreasMode-Enum-Verweise — keine Entsprechung erforderlich
8. Ersetze api.RecognizeImage(path, settings) mit ocr.Read(path)
9. Ersetze api.RecognizePdf(path, settings) mit ocr.Read(path) oder ocr.Read(input) unter Verwendung von input.LoadPdf()
10. Ersetze result.RecognitionText mit result.Text
11. Ersetze result.RecognitionAreasConfidence.Average() mit result.Confidence und multipliziere die alte Schwelle mit 100
12. Ersetze api.SaveMultipageDocument(path, SaveFormat.Pdf, list) mit result.SaveAsSearchablePdf(path)
13. Ersetze api.SaveMultipageDocument(path, SaveFormat.Json, list) mit direkter Serialisierung von result.Pages
14. Konvertieren Sie alle PreprocessingFilter-Ketten zu OcrInput-Methodenaufrufen (siehe API-Zuordnungstabelle)
15. Aktualisieren Sie DocumentRecognitionSettings.StartPage von 0-basierend auf 1-basierend (fügen Sie jedem Wert 1 hinzu)
16. Entfernen Sie die pro-Thread AsposeOcr-Instanziierung — teilen Sie eine einzige IronTesseract-Instanz

Post-Migrationstests

• Führen Sie eine OCR-Analyse an einer repräsentativen Stichprobe jedes Dokumenttyps aus dem Produktiveinsatz durch und vergleichen Sie die Zeichenanzahl mit der Aspose.OCR-Basisausgabe.
• Konfidenzwerte überprüfen:IronOCR gibt Werte zwischen 0 und 100 zurück; bestätigen Sie, dass alle Schwellenwertvergleiche die neue Skala verwenden
• Testen Sie die Auswahl des Seitenbereichs in einer PDF-Datei mit mehr als 1 Seiten unter Verwendung einer 1-basierten Seitenzählung und überprüfen Sie, ob die richtigen Seiten zurückgegeben werden.
• Testen des Imports passwortgeschützter PDFs ohne installiertes Aspose.PDF – Bestätigung, dass keine Abhängigkeitsausnahme auftritt
• Bestätigen Sie, dass result.Text der erwarteten Ausgabe für jedes im Einsatz befindliche DetectAreasMode entspricht (KOMBINIERT, TABELLE, DOKUMENT)
• Testen Sie den JSON-Ausgabepfad: serialisieren Sie result.Pages und validieren Sie das Schema gegen alle nachgelagerten Verbraucher
• Führen Sie den parallelen Batch-Processor aus und vergewissern Sie sich, dass keine Threading-Ausnahmen vorliegen (gemeinsame IronTesseract-Instanz)
• Sicherstellen, dass die durchsuchbare PDF-Datei in einem PDF-Viewer geöffnet wird und der Text an den richtigen Stellen auswählbar ist.
• Sicherstellen, dass der Lizenzschlüssel in jeder Bereitstellungsumgebung (ASP.NET -Start, Azure-Funktion, Docker-Container) fehlerfrei initialisiert wird.
• Überprüfen Sie, dass vorverarbeitete TIFF-Eingaben immer noch durch input.LoadImageFrames() die erwartete Ausgabe erzeugen