IRONSOFTWAREHOME
IRONSUITETodos os 10 pelo preço de 2.
EDIÇÃO DE DOCUMENTOS
IMAGEM E RECONHECIMENTO
CONTATO DE VENDAS
POR EMPRESA
FERRAMENTAS GRATUITAS
JUNTE-SE À NOSSA REDE DE ESPECIALISTAS
VÍDEOS

Migrando do Aspose.OCR para o IronOCR

Kannaopat Udonpant
Kannapat Udonpant
Updated: 20 de junho de 2026

Este guia orienta os desenvolvedores .NET em uma migração completa do Aspose.OCR para o IronOCR . Este documento aborda a troca de pacotes, alterações de namespace, inicialização de licença e quatro exemplos concretos de migração de código extraídos de padrões reais de uso do Aspose.OCR: configuração de definições de reconhecimento, modos de detecção de área, reconhecimento em lote com filtragem baseada em confiança e tratamento de saída estruturada. Cada exemplo mostra a abordagem do Aspose.OCR juntamente com o equivalente do IronOCR, para que você possa traduzir seu código existente sem precisar adivinhar.

Por que migrar do Aspose.OCR?

Os motivos pelos quais as equipes abandonam o Aspose.OCR giram em torno de dois pontos críticos: o modelo de cobrança por assinatura e a complexidade da configuração imposta pelo processo de reconhecimento manual.

Os custos de assinatura acumulam-se indefinidamente. O Aspose.OCR não possui um plano de licença perpétua. A licença para pequenas empresas de desenvolvimento custa US$ 999 por desenvolvedor por ano. Uma equipe de cinco pessoas que renova o contrato por três anos paga US$ 14.985 antes mesmo de escrever uma única linha de lógica de negócios. O plano Professional do IronOCR custa US$ 2.999, pagos uma única vez — a mesma cobertura, para sempre, sem obrigação de renovação. A matemática se torna inescapável quando o setor financeiro questiona por que uma dependência de OCR se renova anualmente como uma assinatura de SaaS.

Cada chamada de reconhecimento requer uma cerimônia de objetos de configuração. Aspose.OCR separa sua superfície de configuração entre RecognitionSettings, DocumentRecognitionSettings, DetectAreasMode e a coleção PreprocessingFilter. Antes de você poder chamar RecognizeImage, você constrói um objeto de configurações, popula-o e passa explicitamente.IronOCR reduz isso a .Read(). A diferença é pequena por chamada; Ele se acumula em toda a base de código.

A seleção do modo de detecção de área é manual e consequente. Aspose.OCR expõe valores DetectAreasMode (COMBINE, DOCUMENT, TABLE, NONE) que o desenvolvedor deve escolher para cada tipo de documento. O modo incorreto em um formulário estruturado reduz a precisão do reconhecimento. O IronOCR analisa automaticamente o layout do documento e exibe o resultado estruturado — parágrafos, linhas, palavras — sem exigir a declaração prévia do modo de operação.

O processamento em lote requer o gerenciamento de listas de resultados manualmente. Salvar um lote de páginas reconhecidas como um PDF pesquisável ou arquivo de dados estruturados no Aspose.OCR significa acumular objetos RecognitionResult em um List<RecognitionResult>, então passar essa lista para SaveMultipageDocument. A organização da lista em tópicos é de sua responsabilidade.IronOCR aceita múltiplas entradas por meio de um único objeto OcrInput e produz um OcrResult cobrindo todas as páginas.

A troca de formato de saída atinge múltiplas superfícies de API. Exportar para JSON, XML ou texto simples no Aspose.OCR requer cada um um valor enum SaveFormat separado passado para SaveMultipageDocument. Filtrar esses resultados por confiança antes de salvar requer iterar a lista e inspecionar cada matriz RecognitionAreasConfidence.IronOCR expõe result.Text, result.Confidence, e result.Pages em um único objeto de resultado — a filtragem por confiança é uma expressão LINQ de uma linha.

O modelo de licenciamento do IronOCR elimina completamente o risco de renovação. Uma licença adquirida é sua para sempre. As atualizações estão incluídas por um ano; Depois disso, a última versão recebida continua funcionando em produção sem apresentar problemas de conformidade. Não existe nenhuma situação em que um pagamento em atraso interrompa sua implantação.

O problema fundamental

O Aspose.OCR vincula a configuração de reconhecimento a um objeto de configurações que deve ser construído, preenchido e passado em cada chamada. O modo, o idioma, os filtros e a estratégia de área são todos propriedades desse objeto:

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

IronOCR usa uma única chamada .Read(). A configuração fica no caso da instância IronTesseract quando necessário, não em um objeto por chamada:

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

##IronOCR vs Aspose.OCR: Comparação de Recursos

A tabela abaixo compara as duas bibliotecas nas dimensões mais importantes durante uma decisão de migração.

RecursoAspose.OCRIronOCR
Modelo de licençaAssinatura anual (sem opção perpétua)Compra única perpétua
1-custo do desenvolvedorUS$ 999/ano$999 uma vez
Custo do desenvolvedor 10US$ 4.995/ano (Licença para o local)US$ 2.999 (Professional)
Consequências da expiração da licençaNão é possível implantar novas versões, não há patches de segurança.Nenhuma — a versão adquirida funciona indefinidamente
Classe primária de OCRAsposeOcrIronTesseract
Objeto de configurações obrigatórioSim (RecognitionSettings ou DocumentRecognitionSettings)Não — OcrInput opcional para cenários avançados
Detecção de áreaSeleção manual enum DetectAreasModeAnálise automática de layout
Pré-processamentoColeta manual PreprocessingFilterAutomático com opção de sobrescrita explícita
Entrada de PDFPDFs padrão via RecognizePdf()Nativo via .Read() ou OcrInput.LoadPdf()
PDF protegido por senhaRequer Aspose.PDF (licença separada)Parâmetro Password: embutido
Saída em PDF pesquisávelSaveMultipageDocument(path, SaveFormat.Pdf, list)result.SaveAsSearchablePdf(path)
Valor de confiançaresult.RecognitionAreasConfidence.Average() (matriz)result.Confidence (único duplo, 0–100)
dados estruturados em nível de palavraGeometria ao nível da área via RecognitionAreasRectanglesresult.Words com X, Y, Largura, Altura, Confiança
dados estruturados em nível de páginaNão expostoresult.Pages com parágrafos, linhas, palavras, caracteres
Simultaneidade multilíngueUm único idioma por chamada.OcrLanguage.French + OcrLanguage.German
Idiomas incluídosMais de 130 no pacote principalMais de 125 idiomas disponíveis através dos pacotes NuGet.
Leitura de código de barrasNão disponívelEmbutido (ocr.Configuration.ReadBarCodes = true)
Segurança da roscaRecomenda-se uma nova instância por thread.Instância única compartilhada, totalmente segura para uso em múltiplas threads
TIFF de múltiplos quadrosNão nativoinput.LoadImageFrames("file.tiff")
Exportação hOCRLimitadoresult.SaveAsHocrFile(path)
NuGet multiplataformaSimSim (Windows, Linux, macOS, Docker, Azure, AWS)
contagem de pacotes NuGet1 pacote de idiomas principal + pacotes de idiomas opcionais1 pacote de idiomas principal + pacotes de idiomas opcionais

Guia rápido: Migração do Aspose.OCR para o IronOCR

Passo 1: Substitua o pacote NuGet

Remover Aspose.OCR:

dotnet remove package Aspose.OCR
SHELL

Instale o IronOCR a partir do NuGet :

> dotnet add package IronOcr

Etapa 2: Atualizar Namespaces

Substitua todas as importações de namespace Aspose.OCR:

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

// After (IronOCR)
using IronOcr;

Etapa 3: Inicializar a licença

Remova a chamada de licença baseada em arquivo da Aspose e substitua-a pela chave de string do IronOCR. Coloque isso na inicialização do aplicativo — uma vez por processo, não uma vez por solicitação:

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

Exemplos de migração de código

Configuração das definições de reconhecimento

Aspose.OCR centraliza todo o comportamento de reconhecimento em um objeto RecognitionSettings. Idioma, modo de detecção de área, sinalizador de linha única e limite, tudo isso está disponível como propriedades. Você o constrói do zero para cada tipo de documento ou padrão de chamada.

Abordagem Aspose.OCR:

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

Abordagem IronOCR:

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

Não há nenhum objeto de configurações para construir por chamada. A linguagem vai na instância IronTesseract; a seleção de região vai em OcrInput no tempo de carga. As decisões DetectAreasMode e RecognizeSingleLine são manejadas automaticamente pelo motor. Para obter orientações detalhadas sobre OCR baseado em região, consulte o guia prático de OCR baseado em região .

Migração do Modo de Detecção de Área

Aspose.OCR requer que você escolha um valor DetectAreasMode antes de cada chamada de reconhecimento. COMBINE mescla texto de diferentes regiões de layout, DOCUMENT trata a imagem como um documento padrão, TABLE otimiza para layouts em grade. Selecionar o modo errado para o tipo de documento causa desalinhamento ou ausência de saída.

Abordagem Aspose.OCR:

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

Abordagem IronOCR:

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

O IronOCR elimina completamente a necessidade de selecionar o modo de operação. O motor analisa o layout e apresenta o resultado através da hierarquia Pages, Paragraphs, Lines, e Words. O guia de resultados de leitura aborda como navegar pelo modelo de resultados estruturados completo para análise de layout de documentos. Para padrões de extração específicos de tabelas, consulte o guia de leitura de tabelas .

Reconhecimento de lotes com filtragem baseada em confiança

Os fluxos de trabalho em lote do Aspose.OCR acumulam objetos RecognitionResult em uma lista. A filtragem por confiança requer iterar essa lista e calcular a média por região antes de aceitar um resultado. A lista deve ser gerenciada explicitamente e passada para SaveMultipageDocument se você quiser gerar várias páginas como um único arquivo.

Abordagem Aspose.OCR:

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

Abordagem IronOCR:

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

result.Confidence é um único double variando de 0 a 100. A média de matriz do RecognitionAreasConfidence da Aspose retorna um float em um intervalo que varia conforme a versão — o limiar de comparação precisa ser ajustado durante a migração. Os índices de confiança orientam os documentos com valores de confiança por palavra, por linha e por página para fluxos de trabalho de validação de documentos. Para padrões de lote de alto volume, consulte o exemplo de multithreading .

Processamento de saída estruturada

Aspose.OCR gera dados estruturados através de SaveMultipageDocument com valores enum SaveFormat específicos do formato. A saída JSON grava um arquivo legível por máquina; a saída XML grava um arquivo de documento anotado. Acessar os dados estruturados brutos — posições das palavras, limites das linhas — requer iterar RecognitionAreasRectangles, que retorna geometria no nível da região, e não no nível da palavra.

Abordagem Aspose.OCR:

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

Abordagem IronOCR:

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

IronOCR expõe dados ao nível de palavra como uma coleção Words direta em cada página, com valores Confidence individuais por palavra. O RecognitionAreasRectangles do Aspose.OCR fornece geometria de região sem um detalhamento de confiança ao nível de palavra. A exportação hOCR gera XHTML compatível com ferramentas que utilizam saída anotada com caixas delimitadoras — consulte o guia de exportação hOCR para obter detalhes sobre o formato. Para o modelo completo de resultado estruturado, a referência API OcrResult documenta todas as propriedades em OcrResult.Page, OcrResult.Paragraph, OcrResult.Line, e OcrResult.Word.

Referência de mapeamento da API Aspose.OCR para o IronOCR

Aspose.OCREquivalente de IronOCR
AsposeOcrIronTesseract
RecognitionSettingsPropriedades em IronTesseract + OcrInput
DocumentRecognitionSettingsOcrInput com LoadPdf() / LoadPdfPages()
api.RecognizeImage(path, settings)ocr.Read(path) ou ocr.Read(input)
api.RecognizePdf(path, settings)ocr.Read(path) ou ocr.Read(input)
result.RecognitionTextresult.Text
result.RecognitionAreasConfidence.Average()result.Confidence (único duplo, 0–100)
result.RecognitionAreasRectanglesresult.Words (com X, Y, Largura, Altura, Confiança)
RecognitionResultOcrResult
Language.EngOcrLanguage.English
DetectAreasMode.COMBINEAutomático — nenhum enum necessário
DetectAreasMode.TABLEAutomático — use result.Pages[n].Paragraphs para layout
DetectAreasMode.DOCUMENTAutomático — análise de layout de gerenciamento do motor
settings.RecognizeSingleLine = trueocr.Configuration.WhiteListCharacters ou corte de região única
settings.RecognitionAreas = new List<Rectangle> { r }input.LoadImage(path, cropRectangle)
settings.AutoSkew = trueAutomático, ou input.Deskew() explícito
PreprocessingFilter.AutoSkew()input.Deskew()
PreprocessingFilter.AutoDenoising()input.DeNoise()
PreprocessingFilter.ContrastCorrectionFilter()input.Contrast()
PreprocessingFilter.Binarize()input.Binarize()
PreprocessingFilter.Threshold(value)input.Binarize() (limiar automático)
PreprocessingFilter.Median()input.DeNoise()
PreprocessingFilter.Scale(factor)input.Scale(percent)
PreprocessingFilter.Invert()input.Invert()
PreprocessingFilter.Rotate(angle)input.Rotate(angle)
api.SaveMultipageDocument(path, SaveFormat.Pdf, list)result.SaveAsSearchablePdf(path)
api.SaveMultipageDocument(path, SaveFormat.Docx, list)Via exportação hOCR: result.SaveAsHocrFile(path)
api.SaveMultipageDocument(path, SaveFormat.Json, list)Navegue result.Pages e serialize diretamente
api.PreprocessImage(path, filters)input.GetPages()[0].SaveAsImage(path)
api.CalculateSkew(imagePath)input.Deskew() (aplica automaticamente o ângulo detectado)
new Aspose.OCR.License().SetLicense("file.lic")IronOcr.License.LicenseKey = "key"
settings.ThreadsCount = nSeguro para uso com múltiplas threads por padrão; use Parallel.ForEach

Problemas e soluções comuns em migrações

Problema 1: O modo DetectAreas não possui equivalente direto.

Aspose.OCR: O código define settings.DetectAreasMode = DetectAreasMode.TABLE ou DetectAreasMode.COMBINE esperando comportamento específico de layout. A remoção da enumeração deixa em aberto a questão de como o IronOCR lida com o mesmo layout.

Solução: Remova o enum completamente. O IronOCR realiza análises de layout automaticamente. Se você precisa inspecionar a estrutura de layout detectada, navegue result.Pages[n].Paragraphs — cada parágrafo carrega um X, Y, Largura, Altura, caixa delimitadora e o texto que contém. Para extração explícita de tabelas, consulte o guia de leitura de tabelas :

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

Problema 2: Incompatibilidade do Limiar de Confiança das Áreas de Reconhecimento

Aspose.OCR: O código existente compara result.RecognitionAreasConfidence.Average() contra um limiar como 0.75f. O result.Confidence do IronOCR está em uma escala diferente.

Solução: result.Confidence é uma porcentagem de 0 a 100. Multiplique seu limiar Aspose por 100 para converter: 0.75f se torna 75.0. Em seguida, atualize toda a lógica de comparação:

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

Problema 3: A saída JSON/XML do SaveMultipageDocument não possui um método direto.

Aspose.OCR: api.SaveMultipageDocument("out.json", SaveFormat.Json, results) escreve um arquivo JSON com metadados de reconhecimento. As equipes que consomem essa saída posteriormente precisam encontrar o equivalente.

**Solução:**IronOCR não tem um método equivalente a SaveFormat.Json. A substituição é navegar result.Pages e serializar com System.Text.Json. Isso lhe dá controle total sobre o esquema:

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 }));

Para saída XHTML com coordenadas incorporadas que ferramentas downstream podem analisar, result.SaveAsHocrFile("output.hocr") é o equivalente semântico mais próximo.

Problema 4: DocumentRecognitionSettings.StartPage usa índice baseado em 0

Aspose.OCR: DocumentRecognitionSettings.StartPage = 2 significa a terceira página (baseado em zero). Este é o erro de deslocamento de uma unidade mais comum nas migrações de Aspose para IronOCR.

Solução: O IronOCR utiliza indexação de páginas baseada em 1 em todo o processo. Adicione 1 a cada valor StartPage e recalcule a página final de acordo. Crie um teste específico para um PDF de várias páginas conhecido, a fim de detectar esse problema antes da produção:

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

Problema 5: RecognizeSingleLine não possui indicador direto

Aspose.OCR: settings.RecognizeSingleLine = true diz ao motor para tratar toda a imagem como uma única linha de texto. Isso é usado para reconhecimento de etiquetas, extração de campos e outras entradas de formato fixo.

Solução: Use um CropRectangle para isolar precisamente a linha de texto, o que impede o motor de executar detecção de layout completa em uma imagem de linha única. Para zonas legíveis por máquina ou formatos de etiquetas, o guia de leitura de documentos específicos aborda a abordagem apropriada:

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

Questão 6: Instâncias Aspose.OCR por thread não são necessárias

Aspose.OCR: A documentação recomenda criar uma nova instância AsposeOcr() por thread para evitar problemas de segurança de thread no processamento paralelo. O código existente cria instâncias dentro de lambdas Parallel.ForEach.

Solução: IronTesseract é seguro para threads. Uma única instância lida com cargas de trabalho paralelas. Remover a instanciação por thread e compartilhar uma única instância:

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

Lista de verificação para migração do Aspose.OCR

Tarefas pré-migração

Audite todas as referências a Aspose.OCR na base de código:

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

Documente cada ocorrência por categoria: chamadas de reconhecimento, objetos de configuração, pipelines de pré-processamento, chamadas de saída e inicialização de licença. Anote todos os valores DetectAreasMode em uso — estes determinam qual caminho de migração de layout se aplica. Registre todos os valores enum SaveFormat — cada formato não-PDF precisa da abordagem de serialização personalizada do Problema 3 acima.

Migração de código

  1. Remova o pacote NuGet Aspose.OCR de todos os projetos na solução
  2. Instale o pacote NuGet IronOcr em todos os projetos
  3. Substitua using Aspose.OCR; e using Aspose.OCR.Models; por using IronOcr;
  4. Substitua new Aspose.OCR.License().SetLicense("file.lic") por IronOcr.License.LicenseKey = "key" no início do aplicativo
  5. Substitua new AsposeOcr() por new IronTesseract()
  6. Remova todos os blocos de construção RecognitionSettings e DocumentRecognitionSettings
  7. Remova todas as referências enum DetectAreasMode — não é necessário equivalente
  8. Substitua api.RecognizeImage(path, settings) por ocr.Read(path)
  9. Substitua api.RecognizePdf(path, settings) por ocr.Read(path) ou ocr.Read(input) usando input.LoadPdf()
  10. Substitua result.RecognitionText por result.Text
  11. Substitua result.RecognitionAreasConfidence.Average() por result.Confidence e multiplique o limiar antigo por 100
  12. Substitua api.SaveMultipageDocument(path, SaveFormat.Pdf, list) por result.SaveAsSearchablePdf(path)
  13. Substitua api.SaveMultipageDocument(path, SaveFormat.Json, list) por serialização direta de result.Pages
  14. Converta todas as cadeias PreprocessingFilter para chamadas de método OcrInput (veja a tabela de mapeamento de API)
  15. Atualize DocumentRecognitionSettings.StartPage de baseado em zero para baseado em 1 (adicione 1 a cada valor)
  16. Remova a instanciação per-thread de AsposeOcr — compartilhe uma única instância IronTesseract

Testes pós-migração

  • Execute o OCR em uma amostra representativa de cada tipo de documento em uso na produção e compare a contagem de caracteres com a saída padrão do Aspose.OCR.
  • Verificar valores de confiança:IronOCR retorna de 0 a 100; Confirme que todas as comparações de limiar utilizam a nova escala.
  • Teste a seleção de intervalo de páginas em um PDF com mais de 10 páginas usando numeração de páginas baseada em 1 e verifique se as páginas corretas são retornadas.
  • Teste a ingestão de PDFs protegidos por senha sem o Aspose.PDF instalado — confirme que não há exceções de dependência.
  • Confirme que result.Text corresponde à saída esperada para cada DetectAreasMode que estava em uso (COMBINAR, TABELA, DOCUMENTO)
  • Teste o caminho de saída JSON: serialize result.Pages e valide o esquema contra quaisquer consumidores downstream
  • Execute o processador em lote paralelo e verifique se não há exceções de threading (instância IronTesseract compartilhada)
  • Confirme se o PDF pesquisável abre em um visualizador de PDF e se o texto pode ser selecionado nos locais corretos.
  • Validar se a chave de licença é inicializada sem erros em cada ambiente de implantação (inicialização do ASP.NET , Função do Azure, contêiner Docker)
  • Verifique se as entradas TIFF pré-processadas ainda produzem a saída esperada através de input.LoadImageFrames()

Principais benefícios da migração para o IronOCR

Custo total de propriedade previsível desde o primeiro dia. A licença Professional de US$ 2.999 cobre 10 desenvolvedores em 10 projetos, sem necessidade de renovação anual. O departamento financeiro fecha o item de linha OCR uma única vez. O impacto orçamentário da contratação de engenheiros, do lançamento de novos projetos ou da extensão do ciclo de vida do produto é zero — não há cálculos de níveis de licença para fazer, nenhuma data de renovação para acompanhar e nenhum risco de não conformidade por falta de pagamento. A página de licenciamento do IronOCR documenta o que cada nível cobre.

Chamadas de reconhecimento que expressam intenção, não infraestrutura. Após a migração, cada chamada de reconhecimento é ocr.Read("document"). A construção RecognitionSettings, seleção DetectAreasMode, e a população PreprocessingFilter que prefixava cada chamada Aspose.OCR desaparece completamente. Os novos engenheiros que leem a camada OCR do código-fonte veem a intenção do negócio — "leia este documento" — em vez de um objeto de configuração sendo montado antes do início do trabalho propriamente dito. A documentação da API do IronTesseract abrange todas as propriedades de configuração disponíveis.

Suporte para PDFs criptografados sem a necessidade de um segundo produto. Os fluxos de trabalho de documentos Enterprise lidam rotineiramente com PDFs protegidos por senha. Após a migração, input.LoadPdf("doc.pdf", Password: "secret") os manipula nativamente. Não há assinatura do Aspose.PDF para gerenciar, nenhum pipeline de descriptografia para imagem para manter e nenhuma segunda data de renovação para acompanhar. Cada formato PDF no processo passa por um único pacote, uma única licença e um único caminho de código. O guia de entrada de PDF aborda intervalos de páginas, seleção não contígua e entrada de fluxo.

Dados de resultados estruturados ao nível de palavra e caractere. result.Pages[n].Words retorna uma coleção onde cada palavra carrega sua caixa delimitadora, seu texto e sua pontuação de confiança individual. A geometria em nível de área do Aspose.OCR abrange regiões, não tokens individuais. Após a migração, os analisadores de layout de documentos, os extratores de campos de formulário e os fluxos de processamento de faturas podem acessar o posicionamento por palavra sem etapas de processamento adicionais. Consulte a página de recursos de resultados de OCR para obter a hierarquia completa de resultados.

Implantação em pacote único para todas as plataformas. O IronOCR é distribuído como um único pacote NuGet que funciona no Windows, Linux, macOS, Docker, Azure App Service e AWS Lambda sem necessidade de configuração específica para cada plataforma. O Aspose.OCR funciona em diversas plataformas, mas pode exigir ajustes na biblioteca nativa em ambientes de contêiner. Após a migração, o Dockerfile para um serviço de OCR é uma imagem base .NET padrão, sem etapas de configuração específicas de OCR além da instalação do pacote. Os guias de implantação abrangem Docker , Azure , AWS e Linux .

Leitura de código de barras na mesma passagem que OCR. Configurar ocr.Configuration.ReadBarCodes = true extrai códigos de barras, códigos QR e símbolos Code 128 da mesma imagem em uma única passagem do motor. O Aspose.OCR não possui funcionalidade de leitura de código de barras — seria necessária uma biblioteca de código de barras separada. Após a migração, documentos que misturam texto impresso com códigos de barras (etiquetas de envio, formulários de inventário, ingressos de eventos) são gerenciados por uma única chamada com resultados em result.Barcodes. Consulte o guia de instruções de OCR de código de barras para obter informações sobre as simbologias suportadas.

Observe: Aspose e Tesseract são marcas registradas de seus respectivos proprietários. Este site não é afiliado, endossado ou patrocinado pela Aspose Pty Ltd ou Google. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.
Kannaopat Udonpant
Kannapat Udonpant
Engenheiro de Software

Artigos relacionados

Key in blue circle

Obtenha sua chave de avaliação gratuita de 30 dias instantaneamente.

Your trial license will be sent to your email address

Sem limitações. 100% desbloqueado. Sem cartão de crédito.

bullet_checkedNão é necessário cartão de crédito nem criação de conta.Sem limitações. 100% desbloqueado. Sem cartão de crédito.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronPDF
Agende sua consulta sem compromisso.
Preencha o formulário abaixo ou envie um e-mail para sales@ironsoftware.com
Os seus dados serão sempre mantidos em sigilo.
Aprovado por milhões de engenheiros em todo o mundo.
Logotipos dos clientes da Iron Software
Obtenha sua chave de avaliação gratuita de 30 dias instantaneamente.
Não é necessário cartão de crédito nem criação de conta.