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 TesseractOCR para o IronOCR

Kannaopat Udonpant
Kannapat Udonpant
Updated: 1 de agosto de 2026

Este guia orienta os desenvolvedores .NET em uma migração completa do pacote NuGetTesseractOCR(o fork de Sicos1977/Kees van Spelde) para o IronOCR . Abrange todo o processo de substituição: remoção de dependências externas de pré-processamento, ativação da entrada nativa de PDF e da saída de PDF pesquisável, atualização de namespaces e chamadas de API e verificação da integração migrada. Não é necessário ler o artigo comparativo previamente.

Por que migrar do TesseractOCR?

OTesseractOCRé um wrapper da comunidade com manutenção ativa, voltado para o .NET moderno e que inclui as bibliotecas nativas do Tesseract 5. A atualização a partir de wrappers mais antigos resolve o problema de compatibilidade com o framework. Isso não resolve as lacunas arquitetônicas que existem abaixo da camada de encapsulamento. Quando essas lacunas surgem na produção, inicia-se a conversa sobre migração.

**O pré-processamento vive inteiramente fora da biblioteca.**TesseractOCRchama engine.Process(image) em qualquer pixel que você fornecer. Uma digitalização distorcida, um fax com baixo contraste, uma foto de recibo tirada com o celular — tudo isso vai direto para o mecanismo Tesseract. Recuperar saída utilizável requer adicionar SixLabors.ImageSharp, SkiaSharp, ou uma biblioteca de imagem semelhante, escrever cadeias de filtros manuais com parâmetros ajustados por tipo de documento, e canalizar a imagem pré-processada através de um arquivo temporário porque TesseractOCR.Pix.Image espera um caminho de arquivo. A correção de desalinhamento (skew) não está disponível nas bibliotecas de processamento de imagens padrão do .NET — ela exige a implementação de um algoritmo de detecção de ângulo de transformada de Hough do zero, o que normalmente requer de 50 a 100 linhas de código adicionais. Este não é um custo de configuração único; ele se repete sempre que um novo tipo de documento entra no fluxo de trabalho.

A entrada de PDFs requer uma segunda biblioteca e um pipeline de arquivos temporários. OTesseractOCRprocessa imagens, não PDFs. Cada fluxo de trabalho de PDF requer um pacote adicional — Docnet.Core, PdfiumViewer ou similar — para renderizar páginas PDF em matrizes de bytes BGRA, um método auxiliar para converter esses bytes em um formato que oTesseractOCRpossa ler e lógica de criação e limpeza de arquivos temporários que envolve todo o loop. O resultado são aproximadamente 100 linhas de código de infraestrutura em torno de cada operação de OCR em PDF. PDFs protegidos por senha requerem uma terceira biblioteca (iText com licença AGPL, ou PDFSharp) apenas para descriptografar antes do processamento.

A saída em PDF pesquisável não possui um caminho definido. Equipes que precisam gerar PDFs legíveis por máquina a partir de documentos digitalizados — um requisito comum para fluxos de trabalho de gerenciamento, arquivamento e conformidade de documentos — descobrem que oTesseractOCRnão oferece nenhum mecanismo para isso. Não há SaveAsSearchablePdf(), não há pipeline hOCR-para-PDF, nenhum formato de saída além do texto extraído. Adicionar essa funcionalidade requer uma biblioteca PDF separada ou o abandono completo do TesseractOCR.

Documentos TIFF com várias páginas exigem um loop de página manual. Arquivos TIFF com várias páginas, comuns em fluxos de trabalho de fax e scanners de documentos, não possuem tratamento nativo para múltiplas páginas no TesseractOCR. A extração de todos os frames requer o carregamento do TIFF com uma biblioteca externa, a iteração entre os frames, o salvamento de cada um em um arquivo temporário e o processamento de cada arquivo temporário pelo mecanismo de OCR separadamente.

O tamanho da comunidade limita o suporte prático. OTesseractOCRtem aproximadamente 200.000 downloads no NuGet . Stack Overflow, postagens de blog e threads de problemas no GitHub sobre wrappers do Tesseract for .NET referenciam esmagadoramente a API charlesw — TesseractEngine, Pix.LoadFromFile — e não a API Sicos1977. A resolução de problemas práticos específicos doTesseractOCResbarra rapidamente nesse obstáculo.

O problema fundamental

OTesseractOCRnão possui pré-processamento nem suporte para PDF. Todo fluxo de trabalho de documentos de produção acaba exigindo bibliotecas externas apenas para chegar ao ponto em que o OCR possa ser executado:

// TesseractOCR: three packages, a temp file, and manual byte conversion
// just to OCR one PDF page — before any preprocessing
// dotnet add package TesseractOCR
// dotnet add package Docnet.Core
// dotnet add package SixLabors.ImageSharp   (preprocessing)

using var library = DocLib.Instance;
using var docReader = library.GetDocReader(pdfPath, new PageDimensions(200, 200));
using var pageReader = docReader.GetPageReader(0);
var bytes = pageReader.GetImage(); // BGRA — not a format Pix.Image accepts directly

string tempPath = Path.GetTempFileName() + ".png";
SaveBgraAsPng(bytes, pageReader.GetPageWidth(), pageReader.GetPageHeight(), tempPath);
// ^ 30+ line helper method needed here

using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
using var image = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
using var page = engine.Process(image);
string text = page.Text;
File.Delete(tempPath); // hope this succeeds
C#
// IronOCR: one package, three lines, preprocessing automatic
// dotnet add package IronOcr

var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadPdf(pdfPath);
string text = ocr.Read(input).Text;
C#

##IronOCR vs TesseractOCR: Comparação de Recursos

A tabela abaixo mapeia as funcionalidades mais importantes durante a avaliação da migração.

RecursoTesseractOCRIronOCR
Pacote NuGetTesseractOCRIronOcr
Compatibilidade com .NET.NET 6.0, 7.0, 8.0.NET Framework 4.6.2+, .NET Core, .NET 5/6/7/8/9
LicençaApache 2.0 (gratuito)Comercial (perpétuo, de $999)
Gestão de dados TessNecessário (download manual do GitHub)Não é necessário (incluído internamente)
Pré-processamento integradoNoneCorrigir distorção, reduzir ruído, aumentar contraste, binarizar, aumentar nitidez, redimensionar, dilatar, erodir, inverter
Remoção profunda de ruído de fundoNãoSim (DeepCleanBackgroundNoise())
Entrada nativa de PDFNão (requer Docnet.Core ou similar)Sim (input.LoadPdf())
PDF protegido por senhaNão (requer biblioteca de terceiros para descriptografar)Sim (parâmetro único Password)
Saída em PDF pesquisávelNãoSim (result.SaveAsSearchablePdf())
Entrada TIFF multiframeNão (requer extração de quadros externos)Sim (input.LoadImageFrames())
Entrada de fluxo e matriz de bytesNão (requer arquivo temporário intermediário)Sim (direto LoadImage(stream), LoadImage(bytes))
Segurança da roscaNão (uma instância do mecanismo por thread)Sim (único IronTesseract compartilhado entre threads)
OCR baseado em regiãoNãoSim (CropRectangle)
Leitura de código de barras durante OCRNãoSim (ocr.Configuration.ReadBarCodes = true)
Saída estruturada (páginas, palavras, coordenadas)Não (somente texto simples)Sim (Pages, Paragraphs, Lines, Words com X/Y)
Pontuação de confiançaFlutuação ao nível do documento (0,0–1,0)Nível de documento e de palavra duplo (0–100)
Exportação hOCRNãoSim
Mais de 125 pacotes NuGet de idiomasNãoSim
Implantação multiplataformaWindows, Linux, macOSWindows, Linux, macOS, Docker, Azure, AWS
Suporte comercialNão (mantenedor voluntário único)Sim (e-mail, opções de SLA)

Guia rápido: Migração doTesseractOCRpara o IronOCR

Passo 1: Substitua o pacote NuGet

Remova oTesseractOCRe quaisquer bibliotecas adicionadas para dar suporte a ele:

dotnet remove package TesseractOCR
dotnet remove package Docnet.Core
dotnet remove package SixLabors.ImageSharp
SHELL

Instale o IronOCR a partir do NuGet :

> dotnet add package IronOcr

Etapa 2: Atualizar Namespaces

Substitua todas as importações do namespaceTesseractOCRpor IronOCR:

// Before (TesseractOCR)
using TesseractOCR;
using TesseractOCR.Enums;

// After (IronOCR)
using IronOcr;
C#

Etapa 3: Inicializar a licença

Adicione a inicialização da licença uma única vez, na inicialização do aplicativo, antes de qualquer chamada de OCR:

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

Uma licença de avaliação gratuita está disponível na página de licenciamento do IronOCR .

Exemplos de migração de código

Substituindo o pipeline de pré-processamento externo

OTesseractOCRrequer uma biblioteca de imagens externa para cada melhoria na qualidade do documento. O código abaixo mostra o padrão que as equipes escrevem quando a qualidade do documento é variável — conversão para escala de cinza, ajuste de contraste, redução de ruído e gravação de um arquivo temporário antes que o OCR possa ser executado. A correção de inclinação (diskew, ou correção de uma digitalização inclinada) não está disponível nas bibliotecas de imagem padrão do .NET e requer um algoritmo separado.

Abordagem TesseractOCR:

// Requires: dotnet add package SixLabors.ImageSharp
// Manual preprocessing — parameters must be tuned per document type
// Deskew is NOT in ImageSharp — requires custom Hough transform (~50-100 lines)

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using TesseractOCR;
using TesseractOCR.Enums;

public string ExtractFromLowQualityScan(string imagePath)
{
    using var image = Image.Load(imagePath);

    image.Mutate(x => x.Grayscale());
    image.Mutate(x => x.Contrast(1.5f));          // manual tuning required
    image.Mutate(x => x.GaussianBlur(0.5f));      // noise reduction approximation
    image.Mutate(x => x.BinaryThreshold(0.5f));   // threshold requires per-doc adjustment

    // Deskew omitted — no built-in support, ~80 lines of additional code

    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        image.Save(tempPath);

        using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
        using var pix = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
        using var page = engine.Process(pix);

        return page.Text;
    }
    finally
    {
        File.Delete(tempPath);
    }
}
C#

Abordagem IronOCR:

// Não external imaging library
// Não temp file — OcrInput accepts a path, stream, or byte array directly
// Deskew is built in — automatic angle detection and correction

using IronOcr;

public string ExtractFromLowQualityScan(string imagePath)
{
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    input.Deskew();           // automatic angle correction
    input.DeNoise();          // intelligent noise removal
    input.Contrast();         // automatic contrast enhancement
    input.Binarize();         // clean black-and-white conversion

    var ocr = new IronTesseract();
    return ocr.Read(input).Text;
}
C#

Remover a dependência do ImageSharp elimina completamente o ciclo de ajuste. O pipeline de pré-processamento OcrInput aplica algoritmos calibrados para OCR de documentos — sem adivinhação em multiplicadores de contraste ou raios de desfoque. O tutorial sobre filtros de imagem e o guia de correção da qualidade da imagem abrangem todos os filtros disponíveis, com opções de parâmetros para os casos em que os valores padrão precisam de ajuste.

Substituindo o processamento TIFF de múltiplos quadros

Documentos de fax, resultados de scanners e arquivos de arquivo frequentemente chegam como arquivos TIFF de várias páginas. OTesseractOCRnão oferece suporte a múltiplos frames — cada frame precisa ser extraído com uma biblioteca externa, salvo em disco e processado pelo mecanismo individualmente. O IronOCR carrega o TIFF inteiro em uma única chamada.

Abordagem TesseractOCR:

// Requires: dotnet add package SixLabors.ImageSharp
// Manual frame extraction — every frame becomes a temp file on disk

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Tiff;
using TesseractOCR;
using TesseractOCR.Enums;

public string ExtractFromMultiPageTiff(string tiffPath)
{
    var allText = new System.Text.StringBuilder();
    var tempFiles = new List<string>();

    try
    {
        using var image = Image.Load(tiffPath);
        using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);

        for (int frameIndex = 0; frameIndex < image.Frames.Count; frameIndex++)
        {
            // Clone frame and save to temp file — no in-memory path
            using var frameImage = image.Frames.CloneFrame(frameIndex);
            string tempPath = Path.GetTempFileName() + ".png";
            tempFiles.Add(tempPath);
            frameImage.SaveAsPng(tempPath);

            using var pix = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
            using var page = engine.Process(pix);

            allText.AppendLine($"=== Frame {frameIndex + 1} ===");
            allText.AppendLine(page.Text);
        }
    }
    finally
    {
        foreach (var f in tempFiles)
            try { File.Delete(f); } catch { }
    }

    return allText.ToString();
}
C#

Abordagem IronOCR:

// Não external library for frame extraction
// All frames processed in one Read() call — no manual loop required

using IronOcr;

public string ExtractFromMultiPageTiff(string tiffPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImageFrames(tiffPath);   // loads all frames automatically
    var result = ocr.Read(input);

    // Access per-page text if needed
    foreach (var page in result.Pages)
        Console.WriteLine($"Frame {page.PageNumber}: {page.Text}");

    return result.Text;
}
C#

O loop de extração de quadros, a lista de arquivos temporários, o bloco de limpeza finally — tudo isso desaparece. Para um fax TIFF de 20 páginas, isso substitui aproximadamente 40 linhas por 6. O guia de entrada TIFF e GIF aborda opções de carregamento de vários quadros, incluindo intervalos de quadros seletivos.

Geração de PDF pesquisável

Este cenário não possui um caminho de migração noTesseractOCR— simplesmente não é possível. Arquivos PDF digitalizados que precisam se tornar documentos legíveis por máquina e com texto selecionável (para indexação de pesquisa, acessibilidade ou arquivamento) exigem a geração de um PDF pesquisável. OTesseractOCRproduz apenas o texto extraído. O IronOCR gera o PDF pesquisável diretamente.

Abordagem TesseractOCR:

// Não path available —TesseractOCRcannot produce any PDF output.
// The closest workaround requires a separate PDF library (iTextSharp AGPL,
// or similar) to overlay extracted text onto the original PDF manually.
// This is 150-300 lines of additional code and introduces AGPL license concerns.

// The best available output from TesseractOCR:
using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
using var pix = TesseractOCR.Pix.Image.LoadFromFile("scanned-page.png");
using var page = engine.Process(pix);

string extractedText = page.Text; // flat string — no PDF output possible
File.WriteAllText("output.txt", extractedText);
// Cannot produce a searchable PDF — no API exists for this
C#

Abordagem IronOCR:

// Native searchable PDF output — no additional library required
// Input can be a scanned image, a scanned PDF, or a multi-page TIFF

using IronOcr;

public void CreateSearchablePdf(string scannedPdfPath, string outputPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdf(scannedPdfPath);
    input.Deskew();     // improve accuracy before generating the output
    input.DeNoise();

    var result = ocr.Read(input);
    result.SaveAsSearchablePdf(outputPath);   // searchable, text-selectable PDF
}
C#

A chamada SaveAsSearchablePdf() incorpora texto OCR no PDF como uma camada invisível por trás da imagem escaneada original. O documento permanece visualmente idêntico, mas torna-se totalmente pesquisável, selecionável e indexável. O guia em PDF pesquisável abrange a API completa, e o exemplo em PDF pesquisável mostra o padrão de funcionamento completo.

Substituindo a entrada de matriz de bytes e eliminando arquivos temporários.

A API Pix.Image doTesseractOCRaceita um caminho de arquivo. Quando os dados da imagem chegam como uma matriz de bytes — de um banco de dados, um upload multipart HTTP ou um cache de memória — oTesseractOCRforça a gravação em um arquivo temporário antes do processamento. A OcrInput do IronOCR aceita arrays de bytes e streams diretamente, removendo a etapa de arquivo temporário inteiramente.

Abordagem TesseractOCR:

// TesseractOCR.Pix.Image has no byte[] or Stream overload
// Every in-memory image must be written to disk before processing

using TesseractOCR;
using TesseractOCR.Enums;

public string ExtractFromBytes(byte[] imageBytes)
{
    // Force a disk write just to satisfy the file-path API
    string tempPath = Path.GetTempFileName() + ".png";

    try
    {
        File.WriteAllBytes(tempPath, imageBytes);

        using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
        using var pix = TesseractOCR.Pix.Image.LoadFromFile(tempPath);
        using var page = engine.Process(pix);

        return page.Text;
    }
    finally
    {
        // Risk: if an exception fires between WriteAllBytes and Delete,
        // temp files accumulate on the server disk
        if (File.Exists(tempPath))
            File.Delete(tempPath);
    }
}
C#

Abordagem IronOCR:

// OcrInput accepts byte arrays and streams natively
// Não disk write, no temp file cleanup, no cleanup failure risk

using IronOcr;

public string ExtractFromBytes(byte[] imageBytes)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imageBytes);   // direct byte array — no temp file
    return ocr.Read(input).Text;
}

public string ExtractFromStream(Stream imageStream)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imageStream);  // direct stream — no intermediate buffer
    return ocr.Read(input).Text;
}
C#

Em aplicações web que processam documentos carregados, o padrão de arquivo temporário acumula uso de disco sob carga e introduz condições de corrida se o código de limpeza gerar uma exceção. O guia de entrada de stream e o guia de entrada de imagens cobrem todos os formatos de entrada suportados, incluindo MemoryStream, byte[], Bitmap, e caminho de arquivo.

Filtragem de confiança em nível de palavra com dados estruturados

OTesseractOCRretorna uma única pontuação de confiança a nível de documento (page.MeanConfidence, um float de 0,0 a 1,0) e uma string de texto plana. Não há confiança por palavra, nem posicionamento de palavras, nem hierarquia estrutural. Criar um fluxo de trabalho que sinalize palavras incertas, extraia regiões específicas ou mapeie texto para coordenadas de documentos exige a mudança para um modelo de saída fundamentalmente diferente.

Abordagem TesseractOCR:

// Only document-level confidence available
// Não word coordinates, no structural hierarchy

using TesseractOCR;
using TesseractOCR.Enums;

public void ProcessWithConfidence(string imagePath)
{
    using var engine = new Engine(@"./tessdata", Language.English, EngineMode.Default);
    using var pix = TesseractOCR.Pix.Image.LoadFromFile(imagePath);
    using var page = engine.Process(pix);

    float docConfidence = page.MeanConfidence; // 0.0 to 1.0 for the whole document

    if (docConfidence >= 0.7f)
        Console.WriteLine($"Accepted ({docConfidence:P0}): {page.Text}");
    else
        Console.WriteLine($"Rejected ({docConfidence:P0}): document needs preprocessing");

    // Não way to identify WHICH words are uncertain
    // Não word coordinates available
}
C#

Abordagem IronOCR:

// Per-word confidence and coordinate data
// Filter individual uncertain words without discarding the whole document

using IronOcr;

public void ProcessWithWordLevelConfidence(string imagePath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadImage(imagePath);
    var result = ocr.Read(input);

    Console.WriteLine($"Document confidence: {result.Confidence}%");

    // Iterate words and flag those below threshold
    foreach (var page in result.Pages)
    {
        foreach (var word in page.Words)
        {
            if (word.Confidence < 70)
            {
                // Low-confidence word — log position for review
                Console.WriteLine(
                    $"Low confidence word '{word.Text}' ({word.Confidence}%) " +
                    $"at X:{word.X} Y:{word.Y}");
            }
        }
    }

    // Extract only high-confidence text
    var reliableWords = result.Pages
        .SelectMany(p => p.Words)
        .Where(w => w.Confidence >= 70)
        .Select(w => w.Text);

    Console.WriteLine(string.Join(" ", reliableWords));
}
C#

A filtragem de confiança por palavra é essencial para o processamento de faturas, extração de formulários e qualquer fluxo de trabalho em que agir com base em texto incerto seja pior do que sinalizá-lo para revisão. O guia de pontuação de confiança abrange o modelo de pontuação completo, e o guia de resultados de leitura documenta a hierarquia completa da saída estruturada.

Referência de mapeamento da API doTesseractOCRpara o IronOCR

TesseractOCRIronOCRNotas
new Engine(tessDataPath, Language.English, EngineMode.Default)new IronTesseract()Não existe um caminho para os dados do tess; Não é necessário selecionar o modo do motor.
TesseractOCR.Pix.Image.LoadFromFile(path)input.LoadImage(path)Também aceita byte[] e Stream
engine.Process(pixImage)ocr.Read(input)Retorna OcrResult em vez de Page
page.Textresult.TextSemântica idêntica
page.MeanConfidence (float 0,0–1,0)result.Confidence (double 0–100)A escala difere — atualize as comparações de limite.
Idioma.Inglês | Idioma.FrancêsOcrLanguage.English + OcrLanguage.FrenchOperador de adição, não OR bit a bit.
EngineMode.DefaultN / DO IronOCR seleciona o modo internamente.
EngineMode.LstmOnlyN / DAutomático
TesseractOCR.Exceptions.TesseractExceptionIronOcr.Exceptions.OcrExceptionMenos tipos de exceção para lidar.
DllNotFoundException (nativo ausente)Não aplicávelO IronOCR inclui suas dependências nativas.
BadImageFormatException (incompatibilidade de arquitetura)Não aplicávelTratado internamente
Externo Image.Mutate(x => x.Grayscale())input.Binarize()Integrado, sem necessidade de biblioteca externa.
Externo Image.Mutate(x => x.Contrast(...))input.Contrast()Calibração automática
distorção da transformada de Hough externainput.Deskew()Integrado, chamada de um método
Filtro de ruído externo GaussianBlurinput.DeNoise()Remoção inteligente de ruído
DocLib.GetDocReader(pdfPath, ...)input.LoadPdf(pdfPath)Não é necessário o Docnet.Core.
docReader.GetPageReader(i).GetImage() + arquivo temporárioinput.LoadPdf(pdfPath)Loop inteiro substituído
input.LoadPdf(encrypted, Password: "...")Parâmetro único — sem necessidade de biblioteca externa.
N / D (sem saída em PDF)result.SaveAsSearchablePdf(outputPath)Não há equivalente no TesseractOCR.
N / D (sem suporte para moldura)input.LoadImageFrames(tiffPath)TIFF com vários quadros em uma única chamada
N / D (apenas o caminho do arquivo)input.LoadImage(stream) / input.LoadImage(bytes)Elimina o padrão de arquivo temporário
Instâncias por thread EngineÚnico IronTesseract compartilhado entre threadsProjetado para ser seguro contra roscas.
page.MeanConfidence (somente documento)word.Confidence por palavraPontuação por palavra disponível

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

Problema 1: Os valores limite de confiança são ultrapassados ​​após a migração.

TesseractOCR: page.MeanConfidence retorna um float no intervalo de 0,0 a 1,0. O código comumente verifica if (confidence >= 0.7f) para aceitar resultados.

Solução: O IronOCR reporta a confiança como um valor duplo em uma escala de 0 a 100. Multiplique todos os valores de limiar existentes por 100. Um limiar de 0.7f torna-se 70.0. A confiança a nível de documento está em result.Confidence; a confiança a nível de palavra está em word.Confidence dentro de result.Pages[n].Words.

// Before (TesseractOCR): page.MeanConfidence >= 0.7f
// After (IronOCR):
var result = new IronTesseract().Read("document.png");
if (result.Confidence >= 70.0)
{
    Console.WriteLine(result.Text);
}
C#

Problema 2: O diretório temporário fica cheio após a tentativa de migração.

TesseractOCR: O código escrito em torno da restrição Pix.Image.LoadFromFile() frequentemente cria arquivos temporários que são limpos em blocos finally. Se o próprio bloco finally arremessa, ou se o aplicativo for encerrado à força, arquivos temporários se acumulam.

Solução: Substitua todos os padrões File.WriteAllBytes(tempPath, bytes) + Pix.Image.LoadFromFile(tempPath) por input.LoadImage(bytes) ou input.LoadImage(stream). Quando nenhum código cria arquivos temporários, a lógica de limpeza e a criação de diretórios para armazenamento temporário podem ser completamente eliminadas. Procure por GetTempFileName, GetTempPath, e SaveBgraAsPng para encontrar todas as ocorrências.

grep -rn "GetTempFileName\|GetTempPath\|SaveBgraAsPng" --include="*.cs" .
SHELL
// Before: byte[] → temp file → Pix.Image.LoadFromFile
// After: byte[] → OcrInput directly
using var input = new OcrInput();
input.LoadImage(imageBytes);   // no disk write
var result = ocr.Read(input);
C#

Consulte o guia de entrada de imagens para obter informações sobre todos os formatos de entrada suportados.

Problema 3: A alteração do operador de linguagem causa erro no compilador

TesseractOCR: OCR multilíngue usa OR bit a bit em uma enumeração de flags: Language.English | Idioma.Francês. Este é um padrão enum [Flags]`.

Solução: O IronOCR usa o operador de adição: OcrLanguage.English + OcrLanguage.French. Eles parecem semelhantes, mas são operadores diferentes. Um localizar e substituir para Language. para OcrLanguage. combinado com | to + dentro de expressões de linguagem lida a maioria dos casos. Verifique se quaisquer combinações de linguagem construídas em tempo de execução também usam +.

// Before (TesseractOCR):
var engine = new Engine(@"./tessdata",
    Language.English | Language.French | Language.German,
    EngineMode.Default);

// After (IronOCR):
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English + OcrLanguage.French + OcrLanguage.German;
C#

Problema 4: Os pacotes Docnet e ImageSharp ainda são referenciados após a desinstalação.

TesseractOCR: Projetos que utilizam oTesseractOCRpara fluxos de trabalho em PDF geralmente têm o Docnet.Core como dependência direta e o SixLabors.ImageSharp ou SkiaSharp para pré-processamento. Após a mudança para o IronOCR, esses pacotes frequentemente permanecem no .csproj porque as declarações de uso não foram totalmente removidas.

Solução: Depois de remover os pacotes do .csproj, procure por quaisquer using Docnet.Core, using SixLabors.ImageSharp, e referências de namespace relacionadas restantes. Se declarações using referenciam namespaces que não existem mais na árvore de dependência, o compilador as apontará — mas somente se os comandos dotnet remove package realmente forem executados.

grep -rn "using Docnet\|using SixLabors\|using SkiaSharp" --include="*.cs" .
SHELL

Remova as referências dos arquivos identificados, então exclua os métodos auxiliares de pré-processamento (SaveBgraAsPng, ApplyGrayscale, ApplyThreshold e semelhantes) que serviram ao antigo pipeline.

Problema 5: O tamanho da imagem Docker aumenta após a migração.

TesseractOCR: Algumas configurações do Docker instalam o Tesseract via apt-get install tesseract-ocr tesseract-ocr-eng como um pacote de sistema, então referenciam esses binários do sistema. Isso adiciona aproximadamente 30 a 80 MB à imagem, dependendo dos pacotes de idiomas.

Solução: O IronOCR inclui seus próprios binários do Tesseract no pacote NuGet . A linha apt-get install tesseract-ocr no Dockerfile não é mais necessária e deve ser removida. Pacotes de linguagem também vêm do NuGet, não de apt-get install tesseract-ocr-fra. O guia de implantação do Docker fornece configurações de imagem base validadas e os pacotes exatos necessários para que o IronOCR seja executado em um contêiner.

# Remove these lines after migration:
# RUN apt-get install -y tesseract-ocr tesseract-ocr-eng tesseract-ocr-fra
# COPY ./tessdata /app/tessdata
Text

Problema 6: TesseractException e DllNotFoundException Blocos Catch Tornam-se Inacessíveis

TesseractOCR: As integrações de produção doTesseractOCRcapturam TesseractOCR.Exceptions.TesseractException, DllNotFoundException (por falta de binários nativos), e BadImageFormatException (por incompatibilidades de arquitetura). Esses tipos de exceção são respostas defensivas à instabilidade do tessdata e à implantação binária nativa.

Solução: O IronOCR inclui as dependências nativas e gerencia a inicialização internamente. DllNotFoundException e BadImageFormatException não se aplicam. Remova esses blocos de retenção. A superfície de exceção reduz para IronOcr.Exceptions.OcrException por falhas do OCR e IOException padrão para problemas de acesso a arquivo.

// Before: five exception types to handle
catch (TesseractOCR.Exceptions.TesseractException ex) { ... }
catch (DllNotFoundException ex) { ... }
catch (BadImageFormatException ex) { ... }
catch (OutOfMemoryException ex) { ... }

// After: two exception types
catch (IronOcr.Exceptions.OcrException ex) { ... }
catch (IOException ex) { ... }
C#

Lista de verificação para migração do TesseractOCR

Pré-migração

Audite todos os pontos de utilização doTesseractOCRno código-fonte:

grep -rn "using TesseractOCR" --include="*.cs" .
grep -rn "new Engine(" --include="*.cs" .
grep -rn "Pix\.Image\.LoadFromFile\|engine\.Process\|page\.Text\|MeanConfidence" --include="*.cs" .
grep -rn "Language\." --include="*.cs" .
SHELL

Identifique toda a infraestrutura de suporte que será removida:

grep -rn "using Docnet\|using SixLabors\|GetTempFileName\|SaveBgraAsPng" --include="*.cs" .
grep -rn "tessdata" --include="*.cs" .
grep -rn "tessdata" --include="*.csproj" .
grep -rn "tessdata" Dockerfile 2>/dev/null || true
SHELL

Documente a linha de base de precisão atual em uma amostra representativa de documentos antes da migração, para que a qualidade pós-migração possa ser verificada.

Migração de código

  1. Execute dotnet remove package TesseractOCR
  2. Execute dotnet remove package Docnet.Core (se presente)
  3. Execute dotnet remove package SixLabors.ImageSharp (se adicionado para pré-processamento)
  4. Execute dotnet add package IronOcr
  5. Adicione IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY" no início do aplicativo
  6. Substitua using TesseractOCR e using TesseractOCR.Enums por using IronOcr
  7. Substitua new Engine(tessDataPath, Language.English, EngineMode.Default) por new IronTesseract()
  8. Substitua TesseractOCR.Pix.Image.LoadFromFile(path) por input.LoadImage(path) em uma instância OcrInput
  9. Substitua engine.Process(pixImage) por ocr.Read(input)
  10. Substitua page.Text por result.Text
  11. Atualize as comparações de limiar de confiança — multiplique todos os valores de 0,0 a 1,0 por 100 para a escala IronOCR de 0 a 100.
  12. Substitua Language.X |Idioma.YwithOcrLanguage.X + OcrLanguage.Y`
  13. Exclua todos os métodos auxiliares de pré-processamento (SaveBgraAsPng, cadeias de filtros manuais, lógica de arquivos temporários)
  14. Substitua loops de renderização de PDF do Docnet por input.LoadPdf(path) ou input.LoadPdfPages(path, start, end)
  15. Substitua loops TIFF de múltiplos quadros por input.LoadImageFrames(tiffPath)
  16. Substitua File.WriteAllBytes(tempPath, bytes) + LoadFromFile(tempPath) por input.LoadImage(bytes)
  17. Atualize blocos catch — remova TesseractException, DllNotFoundException, BadImageFormatException
  18. Remova a pasta tessdata da configuração do diretório de saída do projeto e das imagens do Docker.

Pós-migração

  • Confirme que dotnet build produz zero erros de compilador e zero avisos de catch inacessíveis
  • Execute o OCR na amostra de referência de precisão pré-migração e compare os resultados.
  • Verificar se os arquivos TIFF com várias páginas produzem o número correto de páginas extraídas.
  • Confirme se o PDF pesquisável abre em um visualizador de PDF com texto selecionável.
  • Testar os caminhos de entrada de matrizes de bytes e fluxos de dados das fontes de dados reais do aplicativo.
  • Verifique se os valores de confiança ao nível da palavra estão no intervalo de 0 a 100 (e não de 0,0 a 1,0).
  • Execute testes de processamento paralelo para confirmar que não há avisos de alocação de recursos por thread.
  • Implemente no ambiente de destino (Docker, Azure, Linux) e confirme que o IronOCR inicializa sem DllNotFoundException
  • Verifique se nenhum diretório tessdata ou arquivo .traineddata está referenciado em qualquer lugar nos scripts de implementação

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

O pré-processamento torna-se uma configuração de uma linha, não uma dependência de 100 linhas. Após a migração, input.Deskew(), input.DeNoise(), e input.Contrast() substituem uma biblioteca de imagem externa, ajuste manual de parâmetros e a escrita de arquivo temporário que conectava os dois. Fotos de celular, digitalizações distorcidas e faxes com baixo contraste — tipos de documentos que antes exigiam um engenheiro de pré-processamento dedicado — agora geram resultados confiáveis ​​a partir do fluxo de trabalho integrado. A página de recursos de pré-processamento lista todos os filtros disponíveis.

O PDF é um formato de entrada e saída de primeira classe. A dependência do Docnet, a função auxiliar de conversão de BGRA para PNG, o loop de gerenciamento de arquivos temporários, a terceira biblioteca para arquivos protegidos por senha — tudo isso desaparece. Qualquer PDF que chega no sistema vai diretamente para input.LoadPdf(). Qualquer documento escaneado que precisa se tornar pesquisável sai através de result.SaveAsSearchablePdf(). Todo o processo de processamento de PDF que exigia mais de 100 linhas noTesseractOCRpassa a ser reduzido a um punhado de chamadas de método. Explore a página de casos de uso do OCR para PDF para conhecer toda a gama de fluxos de trabalho de PDF suportados.

A saída estruturada substitui strings de texto planas. result.Pages, result.Paragraphs, result.Lines, e result.Words expõem a estrutura do documento com coordenadas por elemento e pontuações de confiança por palavra. Fluxos de trabalho que antes exigiam heurísticas de análise para encontrar campos específicos — números de faturas, datas, valores — agora podem usar coordenadas em nível de palavra e filtragem de confiança. Esta é a base para a construção de fluxos de trabalho confiáveis ​​de extração de formulários e processamento de documentos, utilizando os recursos de resultados de OCR do IronOCR.

A implantação deixa de exigir a orquestração do tessdata. A pasta tessdata, os scripts de download curl, a camada Docker COPY ./tessdata, a configuração de cache CI/CD para arquivos .traineddata — tudo isso desaparece. Os idiomas são distribuídos como pacotes NuGet , versionados, restaurados com o restante das dependências do projeto e implantados de forma idêntica, independentemente de o destino ser uma estação de trabalho de desenvolvedor, um contêiner Docker, um Serviço de Aplicativo do Azure ou uma função AWS Lambda. O guia de implantação do Azure e o guia de implantação do Linux fornecem configurações validadas para ambientes de produção.

O modelo de licenciamento é previsível. OTesseractOCRé gratuito, mas a infraestrutura que ele exige não é — tempo de desenvolvimento para implementação do pré-processamento, avaliação da biblioteca PDF, scripts de implantação do tessdata e manutenção contínua da cadeia de dependências externas. A licença perpétua do IronOCR($999 Lite, $1.499 Professional, $2.999 Enterprise) é um custo único que substitui semanas de trabalho de infraestrutura e elimina a superfície de manutenção recorrente. O suporte comercial com um caminho de resposta garantido substitui a dependência da fila de problemas do GitHub de um único mantenedor voluntário.

Observe: PDFium, PDFSharp, Tesseract e iText são marcas registradas de seus respectivos proprietários. Este site não é afiliado, endossado ou patrocinado pelo Chromium Project, Google, empira Software GmbH ou iText Group. Todos os nomes de produtos, logos 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.