Aspose.OCR for .NET vs IronOCR: .NET OCR Library

The Manual Preprocessing Model

The fundamental design choice in Aspose.OCR is that you are responsible for knowing what corrections a given image needs. If you feed a skewed, noisy scan without declaring the right filters, the engine processes it as-is:

// Aspose.OCR: developer decides which corrections to apply
var api = new AsposeOcr();
var filters = new Aspose.OCR.Models.PreprocessingFilters.PreprocessingFilter();

// Every filter must be declared explicitly
filters.Add(PreprocessingFilter.AutoSkew());
filters.Add(PreprocessingFilter.AutoDenoising());
filters.Add(PreprocessingFilter.ContrastCorrectionFilter());
filters.Add(PreprocessingFilter.Threshold(128)); // must tune the threshold value

var settings = new RecognitionSettings
{
    PreprocessingFilters = filters,
    Language = Language.Eng
};

var result = api.RecognizeImage("poor-quality-scan.jpg", settings);
return result.RecognitionText;

// Aspose.OCR: developer decides which corrections to apply
var api = new AsposeOcr();
var filters = new Aspose.OCR.Models.PreprocessingFilters.PreprocessingFilter();

// Every filter must be declared explicitly
filters.Add(PreprocessingFilter.AutoSkew());
filters.Add(PreprocessingFilter.AutoDenoising());
filters.Add(PreprocessingFilter.ContrastCorrectionFilter());
filters.Add(PreprocessingFilter.Threshold(128)); // must tune the threshold value

var settings = new RecognitionSettings
{
    PreprocessingFilters = filters,
    Language = Language.Eng
};

var result = api.RecognizeImage("poor-quality-scan.jpg", settings);
return result.RecognitionText;

Imports Aspose.OCR
Imports Aspose.OCR.Models.PreprocessingFilters

' Aspose.OCR: developer decides which corrections to apply
Dim api As New AsposeOcr()
Dim filters As New PreprocessingFilter()

' Every filter must be declared explicitly
filters.Add(PreprocessingFilter.AutoSkew())
filters.Add(PreprocessingFilter.AutoDenoising())
filters.Add(PreprocessingFilter.ContrastCorrectionFilter())
filters.Add(PreprocessingFilter.Threshold(128)) ' must tune the threshold value

Dim settings As New RecognitionSettings With {
    .PreprocessingFilters = filters,
    .Language = Language.Eng
}

Dim result = api.RecognizeImage("poor-quality-scan.jpg", settings)
Return result.RecognitionText

Choose the wrong threshold value and text washes out. Forget AutoDenoising on a salt-and-pepper scan and accuracy drops. The library does not analyze the image and suggest corrections — that analysis is entirely your responsibility. There is also no built-in mechanism to validate that your filter order is sensible; order matters, and the documentation does not cover every interaction.

Detailed Feature Comparison

Aspose.OCR Approach

Aspose sells annual subscriptions with no perpetual path. The moment you stop renewing, you cannot legally deploy new builds and lose access to security patches. From the README:

Small team (3 developers):
  Aspose.OCR: 3 × $783 = per year
  5-year cost: compounding annual subscription fees

Medium team (10 developers):
  Aspose.OCR Site: contact Aspose for current pricing
  5-year cost: compounding annual subscription fees

If your team grows from 3 to 10 developers mid-project, you upgrade to the Site license, resetting the annual clock at a higher rate. Budget planning requires forecasting headcount and assuming annual increases. License expiration consequences documented by Aspose: you cannot deploy new versions, existing deployments require a valid license, and you get no security patches without renewing.

IronOCR Approach

IronOCR's licensing model is a one-time payment per project tier. The Professional tier at $2,999 covers 10 developers across 10 projects. You own that version permanently. One year of updates is included; after that, you continue using the last version you received, or renew updates at a reduced rate. There is no compliance risk from a missed payment.

10-developer team comparison:
  Aspose.OCR Site (5 years):     contact Aspose for current pricing × 5 years
  IronOCR Professional:          $professionalLicense one-time
  Savings: significant over multiple years

For teams shipping internal tools where the product lifecycle extends 5+ years, the compounding cost is not marginal. That delta funds meaningful engineering work.

Aspose.OCR Approach

Every recognition call that needs image correction requires an explicit filter chain. The API is PreprocessingFilter — a collection you build before constructing RecognitionSettings. The order of filters matters and is not automatically validated:

// Aspose.OCR: full pipeline for a typical scanned document
var api = new AsposeOcr();
var filters = new Aspose.OCR.Models.PreprocessingFilters.PreprocessingFilter();

// Step 1: fix rotation (must know to do this first)
filters.Add(PreprocessingFilter.AutoSkew());

// Step 2: remove noise
filters.Add(PreprocessingFilter.AutoDenoising());

// Step 3: contrast
filters.Add(PreprocessingFilter.ContrastCorrectionFilter());

// Step 4: binarize with a threshold you must choose
filters.Add(PreprocessingFilter.Binarize());

var settings = new RecognitionSettings
{
    PreprocessingFilters = filters,
    Language = Language.Eng
};

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

// Aspose.OCR: full pipeline for a typical scanned document
var api = new AsposeOcr();
var filters = new Aspose.OCR.Models.PreprocessingFilters.PreprocessingFilter();

// Step 1: fix rotation (must know to do this first)
filters.Add(PreprocessingFilter.AutoSkew());

// Step 2: remove noise
filters.Add(PreprocessingFilter.AutoDenoising());

// Step 3: contrast
filters.Add(PreprocessingFilter.ContrastCorrectionFilter());

// Step 4: binarize with a threshold you must choose
filters.Add(PreprocessingFilter.Binarize());

var settings = new RecognitionSettings
{
    PreprocessingFilters = filters,
    Language = Language.Eng
};

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

Imports Aspose.OCR
Imports Aspose.OCR.Models

' Aspose.OCR: full pipeline for a typical scanned document
Dim api As New AsposeOcr()
Dim filters As New PreprocessingFilters.PreprocessingFilter()

' Step 1: fix rotation (must know to do this first)
filters.Add(PreprocessingFilter.AutoSkew())

' Step 2: remove noise
filters.Add(PreprocessingFilter.AutoDenoising())

' Step 3: contrast
filters.Add(PreprocessingFilter.ContrastCorrectionFilter())

' Step 4: binarize with a threshold you must choose
filters.Add(PreprocessingFilter.Binarize())

Dim settings As New RecognitionSettings With {
    .PreprocessingFilters = filters,
    .Language = Language.Eng
}

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

For receipts with faded thermal print, the Threshold value needs manual tuning. The example in aspose-ocr-preprocessing-comparison.cs shows the threshold-finding loop: trying values from 80 to 180 in steps of 20 and picking the one that extracts the most characters. That is a legitimate workaround — and it is also developer time your team is spending on OCR plumbing instead of application features.

IronOCR Approach

The default path through IronOCR applies no explicit filters in your code because the engine analyzes each image and applies corrections as needed. The explicit filter methods — Deskew(), DeNoise(), Contrast(), Binarize(), EnhanceResolution() — exist for cases where you want to override the automatic behavior or apply aggressive corrections for particularly degraded inputs:

// IronOCR: automatic preprocessing, zero filter configuration
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

// IronOCR: explicit preprocessing for a heavily degraded low-quality scan
using var input = new OcrInput();
input.LoadImage("poor-quality-photo.jpg");
input.Deskew();
input.DeNoise();
input.Contrast();
input.Binarize();
input.EnhanceResolution(300);
var result = new IronTesseract().Read(input);

// IronOCR: automatic preprocessing, zero filter configuration
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

// IronOCR: explicit preprocessing for a heavily degraded low-quality scan
using var input = new OcrInput();
input.LoadImage("poor-quality-photo.jpg");
input.Deskew();
input.DeNoise();
input.Contrast();
input.Binarize();
input.EnhanceResolution(300);
var result = new IronTesseract().Read(input);

Imports IronOcr

' IronOCR: automatic preprocessing, zero filter configuration
Dim text As String = New IronTesseract().Read("scanned-invoice.jpg").Text

' IronOCR: explicit preprocessing for a heavily degraded low-quality scan
Using input As New OcrInput()
    input.LoadImage("poor-quality-photo.jpg")
    input.Deskew()
    input.DeNoise()
    input.Contrast()
    input.Binarize()
    input.EnhanceResolution(300)
    Dim result = New IronTesseract().Read(input)
End Using

The image quality correction guide covers when explicit preprocessing outperforms the automatic path. For most production inputs — scanned PDFs, office document photos, form captures — the single-line call delivers accurate results without tuning. See the low quality scan examples for benchmark results on degraded inputs.

The practical consequence: an Aspose.OCR integration that handles varied document types requires a per-document-type preprocessing configuration strategy. An IronOCR integration handles varied inputs through the same code path.

Aspose.OCR Approach

Standard PDFs work through RecognizePdf() with DocumentRecognitionSettings. The settings use 0-based page indexing with StartPage and PagesNumber. Non-contiguous page selection requires a loop that calls RecognizePdf once per page:

// Aspose.OCR: standard PDF, all pages
var api = new AsposeOcr();
var settings = new DocumentRecognitionSettings { Language = Language.Eng };
var results = api.RecognizePdf("document.pdf", settings);

var sb = new StringBuilder();
foreach (var page in results)
{
    sb.AppendLine(page.RecognitionText);
}
return sb.ToString();

// Aspose.OCR: standard PDF, all pages
var api = new AsposeOcr();
var settings = new DocumentRecognitionSettings { Language = Language.Eng };
var results = api.RecognizePdf("document.pdf", settings);

var sb = new StringBuilder();
foreach (var page in results)
{
    sb.AppendLine(page.RecognitionText);
}
return sb.ToString();

Imports Aspose.OCR
Imports System.Text

Dim api As New AsposeOcr()
Dim settings As New DocumentRecognitionSettings With {.Language = Language.Eng}
Dim results = api.RecognizePdf("document.pdf", settings)

Dim sb As New StringBuilder()
For Each page In results
    sb.AppendLine(page.RecognitionText)
Next
Return sb.ToString()

Password-protected PDFs are a hard wall. The aspose-ocr-pdf-processing.cs example is unambiguous:

// Aspose.OCR: encrypted PDFs require Aspose.PDF (separate license)
public string ExtractFromProtectedPdf(string pdfPath, string password)
{
    // Aspose.OCR alone CANNOT decrypt PDFs
    // You need Aspose.PDF (additional license cost)

    // Step 1: Decrypt with Aspose.PDF
    // Step 2: Convert pages to images (complex multi-step process)
    // Step 3: OCR the images
    // Step 4: Cleanup temp files

    throw new NotSupportedException(
        "Aspose.OCR requires Aspose.PDF (additional license) to handle " +
        "password-protected PDFs. This adds significant cost and complexity.");
}

// Aspose.OCR: encrypted PDFs require Aspose.PDF (separate license)
public string ExtractFromProtectedPdf(string pdfPath, string password)
{
    // Aspose.OCR alone CANNOT decrypt PDFs
    // You need Aspose.PDF (additional license cost)

    // Step 1: Decrypt with Aspose.PDF
    // Step 2: Convert pages to images (complex multi-step process)
    // Step 3: OCR the images
    // Step 4: Cleanup temp files

    throw new NotSupportedException(
        "Aspose.OCR requires Aspose.PDF (additional license) to handle " +
        "password-protected PDFs. This adds significant cost and complexity.");
}

' Aspose.OCR: encrypted PDFs require Aspose.PDF (separate license)
Public Function ExtractFromProtectedPdf(pdfPath As String, password As String) As String
    ' Aspose.OCR alone CANNOT decrypt PDFs
    ' You need Aspose.PDF (additional license cost)

    ' Step 1: Decrypt with Aspose.PDF
    ' Step 2: Convert pages to images (complex multi-step process)
    ' Step 3: OCR the images
    ' Step 4: Cleanup temp files

    Throw New NotSupportedException(
        "Aspose.OCR requires Aspose.PDF (additional license) to handle " &
        "password-protected PDFs. This adds significant cost and complexity.")
End Function

Aspose.PDF is a separate product with its own annual subscription. If your workflow includes encrypted PDFs — and most enterprise document pipelines do — you are looking at two subscriptions and an integration layer between them.

Creating searchable PDFs also requires accumulating results into a List<RecognitionResult> and calling api.SaveMultipageDocument(outputPdf, SaveFormat.Pdf, results). The step of collecting and threading results through a list is your responsibility.

IronOCR Approach

IronOCR handles standard PDFs, password-protected PDFs, and page range selection through the same OcrInput API. Native PDF OCR requires no additional products:

// IronOCR: standard PDF — direct, no settings object needed
var text = new IronTesseract().Read("document.pdf").Text;

// IronOCR: password-protected PDF — built-in, no extra license
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret123");
var result = new IronTesseract().Read(input);

// IronOCR: non-contiguous pages — single call
using var input = new OcrInput();
input.LoadPdfPages("large-report.pdf", new[] { 1, 3, 5, 12 });
var result = new IronTesseract().Read(input);

// IronOCR: standard PDF — direct, no settings object needed
var text = new IronTesseract().Read("document.pdf").Text;

// IronOCR: password-protected PDF — built-in, no extra license
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret123");
var result = new IronTesseract().Read(input);

// IronOCR: non-contiguous pages — single call
using var input = new OcrInput();
input.LoadPdfPages("large-report.pdf", new[] { 1, 3, 5, 12 });
var result = new IronTesseract().Read(input);

Imports IronOcr

' IronOCR: standard PDF — direct, no settings object needed
Dim text As String = New IronTesseract().Read("document.pdf").Text

' IronOCR: password-protected PDF — built-in, no extra license
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret123")
    Dim result = New IronTesseract().Read(input)
End Using

' IronOCR: non-contiguous pages — single call
Using input As New OcrInput()
    input.LoadPdfPages("large-report.pdf", {1, 3, 5, 12})
    Dim result = New IronTesseract().Read(input)
End Using

Searchable PDF output is a single method call on the result:

// IronOCR: searchable PDF — one line
var result = new IronTesseract().Read("scanned-document.pdf");
result.SaveAsSearchablePdf("searchable-output.pdf");

// IronOCR: searchable PDF — one line
var result = new IronTesseract().Read("scanned-document.pdf");
result.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

' IronOCR: searchable PDF — one line
Dim result = New IronTesseract().Read("scanned-document.pdf")
result.SaveAsSearchablePdf("searchable-output.pdf")

The searchable PDF how-to guide and PDF OCR example cover multi-page and mixed-content PDF scenarios. For document archival workflows where the output requirement is a searchable PDF, the IronOCR path is three lines from input to output with no intermediate state to manage.

Aspose.OCR Approach

Every Aspose.OCR recognition call follows the same pattern: instantiate AsposeOcr, build RecognitionSettings (or DocumentRecognitionSettings for PDFs), optionally populate a PreprocessingFilter collection, call RecognizeImage or RecognizePdf, then access result.RecognitionText. Confidence requires computing result.RecognitionAreasConfidence.Average() because the API returns per-region values:

// Aspose.OCR: basic text extraction with confidence
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    AutoSkew = true
};

var result = api.RecognizeImage("document.jpg", settings);
string text = result.RecognitionText;
float confidence = result.RecognitionAreasConfidence.Average();

// Aspose.OCR: basic text extraction with confidence
var api = new AsposeOcr();
var settings = new RecognitionSettings
{
    Language = Language.Eng,
    AutoSkew = true
};

var result = api.RecognizeImage("document.jpg", settings);
string text = result.RecognitionText;
float confidence = result.RecognitionAreasConfidence.Average();

Imports Aspose.OCR

' Aspose.OCR: basic text extraction with confidence
Dim api As New AsposeOcr()
Dim settings As New RecognitionSettings With {
    .Language = Language.Eng,
    .AutoSkew = True
}

Dim result = api.RecognizeImage("document.jpg", settings)
Dim text As String = result.RecognitionText
Dim confidence As Single = result.RecognitionAreasConfidence.Average()

For batch processing, each image requires its own call and the threading pattern requires instancing AsposeOcr per thread to avoid documented thread-safety concerns:

// Aspose.OCR: parallel batch — instance per thread due to thread-safety considerations
Parallel.ForEach(imagePaths,
    new ParallelOptions { MaxDegreeOfParallelism = 4 },
    path =>
    {
        var api = new AsposeOcr(); // new instance per thread
        var result = api.RecognizeImage(path, new RecognitionSettings());
        // handle result
    });

// Aspose.OCR: parallel batch — instance per thread due to thread-safety considerations
Parallel.ForEach(imagePaths,
    new ParallelOptions { MaxDegreeOfParallelism = 4 },
    path =>
    {
        var api = new AsposeOcr(); // new instance per thread
        var result = api.RecognizeImage(path, new RecognitionSettings());
        // handle result
    });

Imports System.Threading.Tasks
Imports Aspose.OCR

' Aspose.OCR: parallel batch — instance per thread due to thread-safety considerations
Parallel.ForEach(imagePaths, New ParallelOptions With {.MaxDegreeOfParallelism = 4}, Sub(path)
    Dim api As New AsposeOcr() ' new instance per thread
    Dim result = api.RecognizeImage(path, New RecognitionSettings())
    ' handle result
End Sub)

IronOCR Approach

IronOCR's API compresses the common case to one line. The IronTesseract class is thread-safe and reusable across threads without re-instantiation:

// IronOCR: basic text extraction with confidence
var result = new IronTesseract().Read("document.jpg");
string text = result.Text;
double confidence = result.Confidence; // single value, no average needed

// IronOCR: basic text extraction with confidence
var result = new IronTesseract().Read("document.jpg");
string text = result.Text;
double confidence = result.Confidence; // single value, no average needed

Imports IronOcr

' IronOCR: basic text extraction with confidence
Dim result = New IronTesseract().Read("document.jpg")
Dim text As String = result.Text
Dim confidence As Double = result.Confidence ' single value, no average needed

For reading text from images, the reduction in ceremony is most visible in batch scenarios. A single IronTesseract instance handles all parallel work:

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

Parallel.ForEach(imagePaths, path =>
{
    var result = ocr.Read(path);
    // handle result
});

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

Parallel.ForEach(imagePaths, path =>
{
    var result = ocr.Read(path);
    // handle result
});

Imports IronOcr
Imports System.Threading.Tasks

' IronOCR: parallel batch — single shared instance, thread-safe
Dim ocr As New IronTesseract()

Parallel.ForEach(imagePaths, Sub(path)
    Dim result = ocr.Read(path)
    ' handle result
End Sub)

For structured data — word positions, line boundaries, paragraph structure — IronOCR exposes a direct object model through the OcrResult reference. Aspose.OCR accesses word-level data through RecognitionAreasRectangles, which provides area-level geometry rather than a word-level collection with individual confidence values.

When Annual Subscription Costs Become a Budget Line Item

The switch from subscription to perpetual licensing triggers when finance starts asking why OCR renews annually. At the individual developer level, $783/year per developer is a line item that gets attention. For a larger team, it compounds with headcount. Teams that have been on Aspose.OCR for two or three years often calculate they have already paid more than IronOCR's one-time Professional cost at $2,999, and the decision to switch becomes straightforward.

When the PDF Encryption Requirement Appears Late

Document pipelines often start simple — scan images, extract text. Password-protected PDFs arrive later, when the compliance or legal team specifies that all document exports must be encrypted. At that point, Aspose.OCR customers discover they need Aspose.PDF for decryption. That means evaluating a second product, purchasing a second subscription, integrating a decryption step before the OCR call, and managing two license renewals. Teams already invested in Aspose.OCR sometimes absorb this complexity; teams earlier in the evaluation find it easier to select a library that handles encrypted PDFs natively from the start.

When Preprocessing Tuning Becomes a Support Burden

Aspose.OCR's manual filter model works well when your input documents are uniform — same scanner, same settings, same document type. Production document pipelines are rarely uniform. Customer-submitted invoices arrive as phone photos, browser screenshots, faxed copies, and color-photocopied contracts. Each image type benefits from different filter combinations. Teams maintaining Aspose.OCR integrations that cover diverse input types often end up with a per-document-type filter configuration registry and a support queue for the image types that fall outside known patterns. When that maintenance burden becomes visible in sprint planning, the question of whether automatic preprocessing would eliminate the problem becomes worth investigating seriously.

When Developer Onboarding Highlights the API Weight

The verbosity gap is small on a per-call basis but noticeable during onboarding. A new engineer joining a team needs to understand four distinct configuration objects, the difference between image and PDF recognition entry points, the 0-based page indexing convention, and the array-based confidence model. These are not difficult concepts, but they represent a non-trivial surface area to absorb before shipping a first feature. Teams that care about reducing the barrier to contributing to OCR-related code find the simpler IronOCR API cuts the time between "engineer joins team" and "engineer ships OCR feature" measurably.

When a Docker or Linux Deployment Is Introduced

Aspose.OCR's native library dependencies require specific configuration in Docker environments. The difference is usually a few lines in the Dockerfile and some library installations, but it is an undocumented step that surfaces during CI pipeline setup or staging environment provisioning. IronOCR's self-contained package deploys with a standard .NET base image and a single system library installation on Linux. For teams where deployment friction has a cost in engineering hours, this simplification matters.

Namespace and Package Swap

The package replacement is straightforward: dotnet remove package Aspose.OCR followed by dotnet add package IronOcr. The using Aspose.OCR; import becomes using IronOcr;. License activation replaces the Aspose.OCR.License file-based approach:

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

// Add IronOCR license at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
// Or from environment variable (recommended for production)
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

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

// Add IronOCR license at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
// Or from environment variable (recommended for production)
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

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

' Add IronOCR license at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"
' Or from environment variable (recommended for production)
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

The IronTesseract setup guide covers license placement in ASP.NET, Azure Functions, and Windows Service hosts.

Page Index Convention

Aspose.OCR uses 0-based page indexing in DocumentRecognitionSettings.StartPage. IronOCR's LoadPdfPages uses 1-based indexing. The conversion is mechanical: add 1 to every existing StartPage value and adjust the end page calculation. This is the most common off-by-one bug in Aspose-to-IronOCR migrations and worth a targeted test against a multi-page PDF:

// Aspose.OCR: 0-based — first page is StartPage = 0, PagesNumber = 1
var settings = new DocumentRecognitionSettings { StartPage = 0, PagesNumber = 5 };

// IronOCR: 1-based — first page is page 1
using var input = new OcrInput();
input.LoadPdfPages("document.pdf", 1, 5); // pages 1 through 5

// IronOCR: non-contiguous pages
input.LoadPdfPages("document.pdf", new[] { 1, 3, 7 }); // specific page numbers

// Aspose.OCR: 0-based — first page is StartPage = 0, PagesNumber = 1
var settings = new DocumentRecognitionSettings { StartPage = 0, PagesNumber = 5 };

// IronOCR: 1-based — first page is page 1
using var input = new OcrInput();
input.LoadPdfPages("document.pdf", 1, 5); // pages 1 through 5

// IronOCR: non-contiguous pages
input.LoadPdfPages("document.pdf", new[] { 1, 3, 7 }); // specific page numbers

Imports Aspose.OCR
Imports IronOcr

' Aspose.OCR: 0-based — first page is StartPage = 0, PagesNumber = 1
Dim settings As New DocumentRecognitionSettings With {.StartPage = 0, .PagesNumber = 5}

' IronOCR: 1-based — first page is page 1
Using input As New OcrInput()
    input.LoadPdfPages("document.pdf", 1, 5) ' pages 1 through 5

    ' IronOCR: non-contiguous pages
    input.LoadPdfPages("document.pdf", {1, 3, 7}) ' specific page numbers
End Using

The PDF input guide covers all page selection variants including non-contiguous page arrays.

Confidence Value Interpretation

Aspose.OCR returns RecognitionAreasConfidence as an array of per-region float values that typically average somewhere between 0 and 1, scaling varies by version. IronOCR returns result.Confidence as a single double percentage (0–100). If your existing code gates on a confidence threshold, adjust the comparison value accordingly. For granular per-word confidence, IronOCR exposes it directly:

// Aspose.OCR: per-region confidence array averaged to a float
float asposeConfidence = result.RecognitionAreasConfidence.Average();

// IronOCR: single overall confidence value
double confidence = result.Confidence; // 0–100

// IronOCR: per-word confidence when granularity is needed
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}': {word.Confidence:F1}%");
}

// Aspose.OCR: per-region confidence array averaged to a float
float asposeConfidence = result.RecognitionAreasConfidence.Average();

// IronOCR: single overall confidence value
double confidence = result.Confidence; // 0–100

// IronOCR: per-word confidence when granularity is needed
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}': {word.Confidence:F1}%");
}

Imports System
Imports System.Linq

' Aspose.OCR: per-region confidence array averaged to a float
Dim asposeConfidence As Single = result.RecognitionAreasConfidence.Average()

' IronOCR: single overall confidence value
Dim confidence As Double = result.Confidence ' 0–100

' IronOCR: per-word confidence when granularity is needed
For Each word In result.Words
    Console.WriteLine($"'{word.Text}': {word.Confidence:F1}%")
Next

The confidence scores how-to explains how to use per-character, per-word, and per-line confidence values for document validation workflows.

Preprocessing Pipeline Conversion

If you have Aspose.OCR preprocessing pipelines that are tuned for specific document types, the filter-to-method mapping is direct. Each PreprocessingFilter static method maps to an OcrInput instance method. For documents where auto-preprocessing already produces acceptable results, the explicit filters can be removed entirely and the result tested against your accuracy baseline:

// Aspose.OCR preprocessing pipeline
var filters = new PreprocessingFilter();
filters.Add(PreprocessingFilter.AutoSkew());
filters.Add(PreprocessingFilter.ContrastCorrectionFilter());
filters.Add(PreprocessingFilter.AutoDenoising());
filters.Add(PreprocessingFilter.Binarize());

// IronOCR equivalent
using var input = new OcrInput();
input.LoadImage("document.jpg");
input.Deskew();
input.Contrast();
input.DeNoise();
input.Binarize();
var result = new IronTesseract().Read(input);

// Aspose.OCR preprocessing pipeline
var filters = new PreprocessingFilter();
filters.Add(PreprocessingFilter.AutoSkew());
filters.Add(PreprocessingFilter.ContrastCorrectionFilter());
filters.Add(PreprocessingFilter.AutoDenoising());
filters.Add(PreprocessingFilter.Binarize());

// IronOCR equivalent
using var input = new OcrInput();
input.LoadImage("document.jpg");
input.Deskew();
input.Contrast();
input.DeNoise();
input.Binarize();
var result = new IronTesseract().Read(input);

Imports Aspose.OCR
Imports IronOcr

' Aspose.OCR preprocessing pipeline
Dim filters As New PreprocessingFilter()
filters.Add(PreprocessingFilter.AutoSkew())
filters.Add(PreprocessingFilter.ContrastCorrectionFilter())
filters.Add(PreprocessingFilter.AutoDenoising())
filters.Add(PreprocessingFilter.Binarize())

' IronOCR equivalent
Using input As New OcrInput()
    input.LoadImage("document.jpg")
    input.Deskew()
    input.Contrast()
    input.DeNoise()
    input.Binarize()
    Dim result = New IronTesseract().Read(input)
End Using