ABBYY FineReader Engine vs IronOCR for .NET OCR

Initialisation et cycle de vie du moteur

ABBYY requiert une séquence d'initialisation explicite avant toute opération de reconnaissance. Le moteur doit être chargé à partir d'un chemin SDK spécifique avec des fichiers de licence valides, un profil de reconnaissance doit être sélectionné et chaque conteneur de document doit être explicitement fermé après traitement pour éviter les fuites de mémoire :

using FREngine;

public class AbbyyOcrService : IDisposable
{
    private IEngine _engine;

    public AbbyyOcrService(string sdkPath, string licensePath)
    {
        // Step 1: Create engine loader
        var loader = new EngineLoader();

        // Step 2: Load engine — fails if license files are missing or expired
        _engine = loader.GetEngineObject(sdkPath, licensePath);

        // Step 3: Select recognition profile
        _engine.LoadPredefinedProfile("DocumentConversion_Accuracy");

        // Step 4: Configure language data (each language adds deployment complexity)
        var langParams = _engine.CreateLanguageParams();
        langParams.Languages.Add("English");
    }

    public string ExtractText(string imagePath)
    {
        var document = _engine.CreateFRDocument();

        try
        {
            document.AddImageFile(imagePath, null, null);
            document.Process(null);
            return document.PlainText.Text;
        }
        finally
        {
            // Must close — skipping this causes memory leaks
            document.Close();
        }
    }

    public void Dispose()
    {
        _engine = null;
    }
}

using FREngine;

public class AbbyyOcrService : IDisposable
{
    private IEngine _engine;

    public AbbyyOcrService(string sdkPath, string licensePath)
    {
        // Step 1: Create engine loader
        var loader = new EngineLoader();

        // Step 2: Load engine — fails if license files are missing or expired
        _engine = loader.GetEngineObject(sdkPath, licensePath);

        // Step 3: Select recognition profile
        _engine.LoadPredefinedProfile("DocumentConversion_Accuracy");

        // Step 4: Configure language data (each language adds deployment complexity)
        var langParams = _engine.CreateLanguageParams();
        langParams.Languages.Add("English");
    }

    public string ExtractText(string imagePath)
    {
        var document = _engine.CreateFRDocument();

        try
        {
            document.AddImageFile(imagePath, null, null);
            document.Process(null);
            return document.PlainText.Text;
        }
        finally
        {
            // Must close — skipping this causes memory leaks
            document.Close();
        }
    }

    public void Dispose()
    {
        _engine = null;
    }
}

Imports FREngine

Public Class AbbyyOcrService
    Implements IDisposable

    Private _engine As IEngine

    Public Sub New(sdkPath As String, licensePath As String)
        ' Step 1: Create engine loader
        Dim loader = New EngineLoader()

        ' Step 2: Load engine — fails if license files are missing or expired
        _engine = loader.GetEngineObject(sdkPath, licensePath)

        ' Step 3: Select recognition profile
        _engine.LoadPredefinedProfile("DocumentConversion_Accuracy")

        ' Step 4: Configure language data (each language adds deployment complexity)
        Dim langParams = _engine.CreateLanguageParams()
        langParams.Languages.Add("English")
    End Sub

    Public Function ExtractText(imagePath As String) As String
        Dim document = _engine.CreateFRDocument()

        Try
            document.AddImageFile(imagePath, Nothing, Nothing)
            document.Process(Nothing)
            Return document.PlainText.Text
        Finally
            ' Must close — skipping this causes memory leaks
            document.Close()
        End Try
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _engine = Nothing
    End Sub
End Class

Cette séquence s'exécute avant même qu'un seul pixel ne soit traité par reconnaissance optique de caractères (OCR). L'appel loader.GetEngineObject() valide les fichiers de licence, charge les binaires d'exécution à partir du chemin SDK et initialise le moteur de reconnaissance. Si l'un de ces chemins est erroné sur un nouveau serveur de déploiement, l'appel échoue au moment de l'exécution.

Comparaison détaillée des fonctionnalités

Approche d'ABBYY

Le moteur de reconnaissance d'ABBYY offre une précision de premier ordre sur les types de documents les plus difficiles : numérisations historiques de mauvaise qualité, documents à scripts mixtes, texte manuscrit, mises en page de formulaires complexes et documents en mauvais état physique. Le profil DocumentConversion_Accuracy applique le pipeline de reconnaissance complet d'ABBYY :

using FREngine;

// ABBYY: Load high-accuracy profile for difficult documents
var loader = new EngineLoader();
var engine = loader.GetEngineObject(
    @"C:\NProgram Files\NABBYY SDK\NFineReader Engine\Bin",
    @"C:\NProgram Files\NABBYY SDK\NLicense"
);
engine.LoadPredefinedProfile("DocumentConversion_Accuracy");

var document = engine.CreateFRDocument();
try
{
    document.AddImageFile("difficult-scan.jpg", null, null);
    document.Process(null);
    var text = document.PlainText.Text;
}
finally
{
    document.Close();
}

using FREngine;

// ABBYY: Load high-accuracy profile for difficult documents
var loader = new EngineLoader();
var engine = loader.GetEngineObject(
    @"C:\NProgram Files\NABBYY SDK\NFineReader Engine\Bin",
    @"C:\NProgram Files\NABBYY SDK\NLicense"
);
engine.LoadPredefinedProfile("DocumentConversion_Accuracy");

var document = engine.CreateFRDocument();
try
{
    document.AddImageFile("difficult-scan.jpg", null, null);
    document.Process(null);
    var text = document.PlainText.Text;
}
finally
{
    document.Close();
}

Imports FREngine

' ABBYY: Load high-accuracy profile for difficult documents
Dim loader As New EngineLoader()
Dim engine = loader.GetEngineObject(
    "C:\NProgram Files\NABBYY SDK\NFineReader Engine\Bin",
    "C:\NProgram Files\NABBYY SDK\NLicense"
)
engine.LoadPredefinedProfile("DocumentConversion_Accuracy")

Dim document = engine.CreateFRDocument()
Try
    document.AddImageFile("difficult-scan.jpg", Nothing, Nothing)
    document.Process(Nothing)
    Dim text = document.PlainText.Text
Finally
    document.Close()
End Try

Qu'il s'agisse de dossiers médicaux comportant des annotations manuscrites, de documents juridiques présentant des traces d'usure physique accumulées au fil des décennies ou d'archives gouvernementales numérisées à partir de microfilms, l'avantage d'ABBYY en termes de précision par rapport aux solutions modernes basées sur Tesseract est mesurable et déterminant.

Approche d'IronOCR

IronOCR atteint une précision de 95 à 99 % sur les documents professionnels standard — factures, reçus, contrats, formulaires, rapports numérisés — grâce à un prétraitement automatique qui corrige les erreurs les plus courantes avant que le moteur LSTM de Tesseract 5 ne traite l'image :

using IronOcr;

// IronOCR: Prétraitement automatique handles most real-world document quality issues
var ocr = new IronTesseract();
var result = ocr.Read("invoice-scan.jpg");
Console.WriteLine(result.Text);
Console.WriteLine($"Confidence: {result.Confidence}%");

using IronOcr;

// IronOCR: Prétraitement automatique handles most real-world document quality issues
var ocr = new IronTesseract();
var result = ocr.Read("invoice-scan.jpg");
Console.WriteLine(result.Text);
Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

' IronOCR: Prétraitement automatique handles most real-world document quality issues
Dim ocr As New IronTesseract()
Dim result = ocr.Read("invoice-scan.jpg")
Console.WriteLine(result.Text)
Console.WriteLine($"Confidence: {result.Confidence}%")

Lorsque la qualité des données d'entrée est vraiment médiocre, des filtres de prétraitement explicites offrent un contrôle total :

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();           // Correct rotation up to several degrees
input.DeNoise();          // Remove scanner noise and artifacts
input.Contrast();         // Enhance text/background separation
input.Binarize();         // Convert to optimal black/white
input.EnhanceResolution(300);  // Scale to 300 DPI for engine

var result = new IronTesseract().Read(input);

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();           // Correct rotation up to several degrees
input.DeNoise();          // Remove scanner noise and artifacts
input.Contrast();         // Enhance text/background separation
input.Binarize();         // Convert to optimal black/white
input.EnhanceResolution(300);  // Scale to 300 DPI for engine

var result = new IronTesseract().Read(input);

Imports IronOcr

Using input As New OcrInput()
    input.LoadImage("low-quality-scan.jpg")
    input.Deskew()           ' Correct rotation up to several degrees
    input.DeNoise()          ' Remove scanner noise and artifacts
    input.Contrast()         ' Enhance text/background separation
    input.Binarize()         ' Convert to optimal black/white
    input.EnhanceResolution(300)  ' Scale to 300 DPI for engine

    Dim result = New IronTesseract().Read(input)
End Using

Le guide de correction de la qualité d'image couvre l'effet de chaque filtre sur la précision de la reconnaissance. Pour 99 % des flux de documents d'entreprise — factures, bons de commande, contrats, documents d'identité, formulaires imprimés —, le moteur Tesseract 5 prétraité d'IronOCR offre une précision pratiquement impossible à distinguer de celle d'ABBYY. Le 1 % restant concerne l'écriture manuscrite dégradée, les documents historiques ou les combinaisons de scripts de niche, où l'avance d'ABBYY devient significative.

Approche d'ABBYY

L'installation d'ABBYY FineReader Engine suit cette séquence une fois la licence approuvée :

Structure d'installation après l'exécution du programme d'installation du SDK ABBYY :
C:\NProgram Files\NABBYY SDK\N
├── Moteur FineReader\
│   ├── Bin\          ← Binaires SDK (référence d'assemblage manuel requise)
│   ├── Inc\          ← Fichiers d'en-tête
│   ├── Lib\          ← Bibliothèques
│   └── Licence\      ← Fichiers de licence (ABBYY.lic + ABBYY.key)
└── Durée d'exécution\
    ├── Langues\    ← Fichiers de données linguistiques (volumineux, à déployer)
    └── Dictionnaires\ ← Fichiers de dictionnaires (à déployer)

Chaque cible de déploiement — poste de travail du développeur, serveur de build, environnement de préproduction, serveur de production — nécessite que ce programme d'installation s'exécute avec des privilèges d'administrateur. Les fichiers de licence doivent se trouver aux emplacements attendus sur chaque machine. Dans les conteneurs Docker, cela implique soit d'intégrer le SDK dans une image de base personnalisée, soit de le monter en tant que volume, deux opérations qui nécessitent un travail d'infrastructure important.

La validation de licence lors de l'exécution vérifie l'existence et la validité des fichiers. Si le fichier .lic est manquant, l'appel loader.GetEngineObject() est lancé au démarrage. Si la licence a expiré, le même échec se produit en production.

Approche d'IronOCR

dotnet add package IronOcr

dotnet add package IronOcr

Cette commande gère tout : le moteur OCR, les données en anglais et toutes les dépendances binaires natives pour la plateforme actuelle. Les cibles multiplateformes sont incluses dans le même package. Un déploiement Dockerne nécessite aucune image de base personnalisée :

FROM mcr.microsoft.com/dotnet/aspnet:8.0
RUN apt-get update && apt-get install -y libgdiplus
COPY --from=build /app/publish /app
WORKDIR /app
ENTRYPOINT ["dotnet", "YourApp.dll"]

L'activation de la licence se fait en une seule ligne dans le code de démarrage :

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

Imports System

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

Pas de fichiers à copier, pas de chemins d'accès à configurer, pas de serveur de licences à gérer. Le Guide de déploiement de Docker couvre les spécificités des conteneurs Linux, y compris l'exigence libgdiplus. Le même package NuGetse déploie de manière identique sur Azure, AWS Lambda et les serveurs Linux.

Approche d'ABBYY

Le traitement ABBYY PDF nécessite l'ouverture du PDF via un objet CreatePDFFile() séparé, l'itération des pages, l'ajout de chaque page à un conteneur de document, l'exécution de la passe de reconnaissance, puis l'exportation à l'aide des paramètres d'exportation configurés :

using FREngine;

public string ProcessPdf(string pdfPath)
{
    var document = _engine.CreateFRDocument();

    try
    {
        // Open PDF through a separate file object
        var pdfFile = _engine.CreatePDFFile();
        pdfFile.Open(pdfPath, null, null);

        // Add each page individually
        for (int i = 0; i < pdfFile.PageCount; i++)
        {
            document.AddImageFile(
                pdfPath,
                null,
                _engine.CreatePDFExportParams()
            );
        }

        document.Process(null);
        return document.PlainText.Text;
    }
    finally
    {
        document.Close();
    }
}

public void CreateSearchablePdf(string inputPath, string outputPath)
{
    var document = _engine.CreateFRDocument();

    try
    {
        document.AddImageFile(inputPath, null, null);
        document.Process(null);

        // Configure export parameters before export
        var exportParams = _engine.CreatePDFExportParams();
        exportParams.Scenario = PDFExportScenarioEnum.PDES_Balanced;

        document.Export(outputPath, FileExportFormatEnum.FEF_PDF, exportParams);
    }
    finally
    {
        document.Close();
    }
}

using FREngine;

public string ProcessPdf(string pdfPath)
{
    var document = _engine.CreateFRDocument();

    try
    {
        // Open PDF through a separate file object
        var pdfFile = _engine.CreatePDFFile();
        pdfFile.Open(pdfPath, null, null);

        // Add each page individually
        for (int i = 0; i < pdfFile.PageCount; i++)
        {
            document.AddImageFile(
                pdfPath,
                null,
                _engine.CreatePDFExportParams()
            );
        }

        document.Process(null);
        return document.PlainText.Text;
    }
    finally
    {
        document.Close();
    }
}

public void CreateSearchablePdf(string inputPath, string outputPath)
{
    var document = _engine.CreateFRDocument();

    try
    {
        document.AddImageFile(inputPath, null, null);
        document.Process(null);

        // Configure export parameters before export
        var exportParams = _engine.CreatePDFExportParams();
        exportParams.Scenario = PDFExportScenarioEnum.PDES_Balanced;

        document.Export(outputPath, FileExportFormatEnum.FEF_PDF, exportParams);
    }
    finally
    {
        document.Close();
    }
}

Imports FREngine

Public Function ProcessPdf(ByVal pdfPath As String) As String
    Dim document = _engine.CreateFRDocument()

    Try
        ' Open PDF through a separate file object
        Dim pdfFile = _engine.CreatePDFFile()
        pdfFile.Open(pdfPath, Nothing, Nothing)

        ' Add each page individually
        For i As Integer = 0 To pdfFile.PageCount - 1
            document.AddImageFile(pdfPath, Nothing, _engine.CreatePDFExportParams())
        Next

        document.Process(Nothing)
        Return document.PlainText.Text
    Finally
        document.Close()
    End Try
End Function

Public Sub CreateSearchablePdf(ByVal inputPath As String, ByVal outputPath As String)
    Dim document = _engine.CreateFRDocument()

    Try
        document.AddImageFile(inputPath, Nothing, Nothing)
        document.Process(Nothing)

        ' Configure export parameters before export
        Dim exportParams = _engine.CreatePDFExportParams()
        exportParams.Scenario = PDFExportScenarioEnum.PDES_Balanced

        document.Export(outputPath, FileExportFormatEnum.FEF_PDF, exportParams)
    Finally
        document.Close()
    End Try
End Sub

Approche d'IronOCR

IronOCR gère les entrées PDF en natif — pas d'itération de pages, pas d'objets de fichiers séparés, pas de configuration de paramètres d'exportation :

using IronOcr;

// Read any PDF — multi-page handled automatically
using var input = new OcrInput();
input.LoadPdf("scanned-document.pdf");
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

// PDF protégé par mot de passe — one parameter
using var secureInput = new OcrInput();
secureInput.LoadPdf("encrypted.pdf", Password: "secret");
var secureResult = new IronTesseract().Read(secureInput);

// Create searchable PDF — one method call
var ocrResult = new IronTesseract().Read("scanned.pdf");
ocrResult.SaveAsSearchablePdf("searchable-output.pdf");

using IronOcr;

// Read any PDF — multi-page handled automatically
using var input = new OcrInput();
input.LoadPdf("scanned-document.pdf");
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

// PDF protégé par mot de passe — one parameter
using var secureInput = new OcrInput();
secureInput.LoadPdf("encrypted.pdf", Password: "secret");
var secureResult = new IronTesseract().Read(secureInput);

// Create searchable PDF — one method call
var ocrResult = new IronTesseract().Read("scanned.pdf");
ocrResult.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

' Read any PDF — multi-page handled automatically
Using input As New OcrInput()
    input.LoadPdf("scanned-document.pdf")
    Dim result = New IronTesseract().Read(input)
    Console.WriteLine(result.Text)
End Using

' PDF protégé par mot de passe — one parameter
Using secureInput As New OcrInput()
    secureInput.LoadPdf("encrypted.pdf", Password:="secret")
    Dim secureResult = New IronTesseract().Read(secureInput)
End Using

' Create searchable PDF — one method call
Dim ocrResult = New IronTesseract().Read("scanned.pdf")
ocrResult.SaveAsSearchablePdf("searchable-output.pdf")

Le guide PDF consultable couvre les options de sortie, notamment l'intégration de la couche de texte dans des scans PDF existants. L'exemple d'OCR de PDF illustre le traitement multipages avec accès aux résultats page par page.

Approche d'ABBYY

ABBYY ne publie pas ses tarifs. Tous les chiffres nécessitent un engagement commercial pour être obtenus. D'après des rapports sectoriels et des discussions au sein de la communauté des développeurs :

• Licence de développement : 4 999 $ - 15 000 $+ (estimation)
• Licence d'exécution : par serveur (5 000 à 20 000 $+/an) ou par page (0,01 à 0,10 $/page, en fonction du volume)
• Maintenance annuelle : 20 à 25 % du coût de la licence par an
• Services professionnels : 200-400 $/heure

Une équipe de taille moyenne traitant 100 000 pages par mois sur un seul serveur de production doit s'attendre à un coût total de possession sur trois ans supérieur à 50 000 $ — licence de développement plus licence d'exécution plus frais de maintenance annuels.

Le modèle de licence à la page entraîne des coûts à grande échelle. À 0,01 $ par page pour 100 000 pages par mois, cela représente 1 000 $ par mois en coûts variables, soit 12 000 $ par an, sans plafond.

Approche d'IronOCR

La licence IronOCR est perpétuelle et publiée :

• Lite : 749 $ (1 développeur, 1 projet)
• Plus : 1 499 $ (3 développeurs, 3 projets)
• Professional : 2 999 $ (10 développeurs, 10 projets)
• Illimité : 5 999 $ (nombre illimité de développeurs et de projets)

Pas de frais d'exécution. Pas de coût à la page. Aucune exigence de maintenance annuelle. Pas de cycle de renouvellement. The Professional License costs 2 999 $ and covers a team of 10 developers processing any volume of documents on an unlimited number of servers, indefinitely.

Comparaison du coût total de possession (TCO) sur trois ans pour le scénario d'une équipe de taille moyenne : ABBYY est estimé à plus de 50 000 $, IronOCR Professional à 2 999 $. L'écart de précision qui les sépare sur les documents commerciaux standard ne comble pas cet écart pour la grande majorité des cas d'utilisation.

Le renouvellement de licence déclenche une analyse coûts-avantages

Les factures de maintenance annuelle d'ABBYY s'élèvent généralement à 20-25 % du coût initial de la licence chaque année. Pour une équipe qui a déboursé 10 000 $ pour la licence de développement et 15 000 $ pour la licence d'exécution, la deuxième année s'accompagne d'une facture de maintenance de 6 250 $ avant même qu'une seule ligne de nouveau code ne soit écrite. Ce moment de renouvellement incite les équipes à se demander si l'écart de précision sur leurs types de documents spécifiques — généralement des documents commerciaux standard — justifie le coût continu. Les équipes chargées du traitement des factures, de la numérisation des contrats ou de l'extraction de formulaires numérisés constatent régulièrement que le moteur Tesseract 5 pré-traité d'IronOCR offre une précision pratique équivalente à un coût de quelques centaines de dollars plutôt que de plusieurs dizaines de milliers.

Nouveau projet sans relation existante avec ABBYY

Les équipes de développement qui lancent un nouveau projet OCR à partir de zéro sont confrontées à la réalité des délais d'approvisionnement : 4 à 12 semaines pour obtenir l'accès au SDK ABBYY signifient 4 à 12 semaines de développement bloqué. Pour une équipe soumise à une échéance de prototypage ou à un engagement de sprint, ce cycle d'approvisionnement n'est pas envisageable. IronOCR s'installe en moins d'une minute et produit des résultats OCR le jour même. Les équipes qui évaluent des solutions OCR pour un nouveau produit choisissent souvent IronOCR, non pas parce qu'ABBYY manque de capacités, mais parce qu'elles doivent livrer leur produit et ne peuvent pas attendre la fin d'un cycle de vente.

Modernisation de l'infrastructure de déploiement

Les applications construites sur la couche d'interopérabilité COM d'ABBYY rencontrent des difficultés lors du passage vers des conteneurs, Kubernetes ou des architectures cloud natives. Le programme d'installation du SDK, les dépendances des fichiers de licence, la structure du répertoire d'exécution : aucun de ces éléments ne s'intègre parfaitement dans une image Dockerconstruite à partir d'une image de base .NET Standard. Les équipes qui conténérisent une application de traitement de documents héritée constatent que le modèle de déploiement d'ABBYY nécessite soit une image de base personnalisée intégrant l'installation complète du SDK, soit des montages de volumes pour les fichiers de licence, avec toute la complexité opérationnelle que cela implique. Le paquet NuGetd'IronOcr se déploie dans n'importe quel conteneur sans aucune modification de l'image de base, hormis l'ajout de libgdiplus pour les cibles Linux.

Contraintes budgétaires pour les petites équipes

Les startups, les éditeurs de logiciels indépendants et les équipes internes chargées des outils évaluent fréquemment les capacités d'ABBYY et les trouvent convaincantes, avant de découvrir que les tarifs nécessitent l'approbation d'un budget de niveau Enterprise. Une équipe développant un outil de traitement des factures pour une entreprise de taille moyenne ne peut justifier une licence de développement à 15 000 $ plus 10 000 $ de frais d'exécution annuels alors que son budget logiciel annuel total s'élève à 20 000 $. La Lite License d'IronOCR à 749 $ ou la Professional License à 2 999 $ s'inscrit dans le cadre du pouvoir d'achat discrétionnaire d'un seul ingénieur.

L'augmentation du volume de documents met en évidence la structure des coûts par page

Les applications qui démarrent modestement et se développent se heurtent à un obstacle avec les licences ABBYY facturées à la page. Une start-up traitant 10 000 documents par mois à son lancement passe à 500 000 documents par mois en l'espace de deux ans. À 0,01 $ par page, cette trajectoire de croissance fait passer les coûts d'ABBYY de gérables à déterminants pour le budget. La licence perpétuelle d'IronOCR ne comporte pas de composante au page : le traitement de 10 000 documents ou de 10 000 000 de documents coûte le même prix.

Remplacement de la gestion du cycle de vie des moteurs

Le travail de migration le plus chronophage consiste à supprimer le code d'initialisation et de cycle de vie explicite d'ABBYY. Chaque appel loader.GetEngineObject(), LoadPredefinedProfile(), et document.Close()est supprimé. Le IronTesseract d'IronOCR s'instancie directement sans chargeur, sans chargement de profil et avec un nettoyage automatique grâce au motif using standard. Le temps de migration typique pour des modèles d'extraction de texte de base est de 2 à 4 heures :

// Remove all of this:
// var loader = new EngineLoader();
// _engine = loader.GetEngineObject(sdkPath, licensePath);
// _engine.LoadPredefinedProfile("DocumentConversion_Accuracy");
// var document = _engine.CreateFRDocument();
// document.AddImageFile(imagePath, null, null);
// document.Process(null);
// string text = document.PlainText.Text;
// document.Close();

// Replace with:
var text = new IronTesseract().Read(imagePath).Text;

// Remove all of this:
// var loader = new EngineLoader();
// _engine = loader.GetEngineObject(sdkPath, licensePath);
// _engine.LoadPredefinedProfile("DocumentConversion_Accuracy");
// var document = _engine.CreateFRDocument();
// document.AddImageFile(imagePath, null, null);
// document.Process(null);
// string text = document.PlainText.Text;
// document.Close();

// Replace with:
var text = new IronTesseract().Read(imagePath).Text;

Imports IronOcr

Dim text As String = New IronTesseract().Read(imagePath).Text

Suppression de l'infrastructure de licence

Après la migration, le pipeline de déploiement est considérablement simplifié. L'étape d'installation d'ABBYY SDK est supprimée des scripts CI/CD. Les fichiers de licence (ABBYY.lic, ABBYY.key) sont supprimés des artefacts de déploiement. Si un serveur de licences était en service, cette infrastructure peut être mise hors service. La clé de licence IronOCR réside dans une variable d'environnement ou un gestionnaire de secrets — aucun fichier, aucun serveur, aucune dépendance réseau n'est nécessaire pour la validation de la licence. Le guide d'installation d'IronTesseract couvre la configuration initiale, y compris l'emplacement de la clé de licence pour divers environnements de déploiement.

Extraction basée sur les zones ou sur les régions

L'extraction de régions basée sur les zones d'ABBYY (_engine.CreateZone(), zone.SetBounds(), zone.Type = ZoneTypeEnum.ZT_Text, page.Zones.Add(zone)) correspond à l'approche CropRectangle d'IronOcr. Les concepts sont équivalents ; l'API est plus simple :

// ABBYY zone-based extraction required zone creation,
// bounds setting, type assignment, and page.Zones.Add()

// IronOCR: CropRectangle passed directly to LoadImage
var region = new CropRectangle(x: 0, y: 0, width: 600, height: 100);
using var input = new OcrInput();
input.LoadImage("invoice.jpg", region);
var headerText = new IronTesseract().Read(input).Text;

// ABBYY zone-based extraction required zone creation,
// bounds setting, type assignment, and page.Zones.Add()

// IronOCR: CropRectangle passed directly to LoadImage
var region = new CropRectangle(x: 0, y: 0, width: 600, height: 100);
using var input = new OcrInput();
input.LoadImage("invoice.jpg", region);
var headerText = new IronTesseract().Read(input).Text;

Imports IronOcr

' ABBYY zone-based extraction required zone creation,
' bounds setting, type assignment, and page.Zones.Add()

' IronOCR: CropRectangle passed directly to LoadImage
Dim region As New CropRectangle(x:=0, y:=0, width:=600, height:=100)
Using input As New OcrInput()
    input.LoadImage("invoice.jpg", region)
    Dim headerText As String = New IronTesseract().Read(input).Text
End Using

Le guide OCR basé sur la région couvre l'utilisation de CropRectangle pour les modèles d'extraction de champs courants dans le traitement des factures et des formulaires.

Accès aux données structurées

L'accès aux données structurées par blocs d'ABBYY (page.Layout.Blocks, BlockTypeEnum.BT_Table, block.GetAsTableBlock()) n'a pas d'équivalent direct un à un dans IronOcr. IronOcr expose des résultats structurés à travers result.Pages, result.Lines, result.Words, et result.Paragraphs, chacun avec des données de coordonnées. En ce qui concerne spécifiquement l'extraction de tableaux, le guide des résultats de lecture explique comment accéder aux données de positionnement au niveau des WORDs, ce qui permet de reconstruire les tableaux.