Aspose.OCR'den IronOCR'a Geçiş

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

dotnet remove package Aspose.OCR

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

// After (IronOCR)
using IronOcr;

Imports IronOcr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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