API OCR Microsoft Azure Vision vs. IronOCR: laquelle gère le mieux les images de documents ?

Le fossé du prétraitement

Le prétraitement n'est pas une option de configuration que vous pouvez ignorer. Il fait toute la différence entre une précision optimale en production et des résultats inutilisables sur des documents réels. Le fichier source image-preprocessing-tesseract.cs pour ce wrapper documente le pipeline manuel complet :

// Tesseract requires every one of these steps to be written manually
public static string ExtractWithPreprocessing(string imagePath)
{
    using (var original = new Bitmap(imagePath))
    {
        // Step 2: Convert to grayscale (~25 lines)
        using (var grayscale = ConvertToGrayscale(original))
        {
            // Step 3: Apply contrast enhancement (~15 lines)
            using (var enhanced = EnhanceContrast(grayscale))
            {
                // Step 4: Binarize — convert to black and white (~15 lines)
                using (var binarized = Binarize(enhanced, 128))
                {
                    // Step 5: Remove noise (~25 lines)
                    using (var denoised = RemoveNoise(binarized))
                    {
                        // Step 6: Déclin if rotated (~50 lines, simplified)
                        using (var deskewed = Deskew(denoised))
                        {
                            // Step 7: Scale to 300 DPI (~20 lines)
                            using (var scaled = ScaleToDpi(deskewed, 300))
                            {
                                return RunTesseract(scaled);  // Save to temp file, load Pix, process
                            }
                        }
                    }
                }
            }
        }
    }
}

// Tesseract requires every one of these steps to be written manually
public static string ExtractWithPreprocessing(string imagePath)
{
    using (var original = new Bitmap(imagePath))
    {
        // Step 2: Convert to grayscale (~25 lines)
        using (var grayscale = ConvertToGrayscale(original))
        {
            // Step 3: Apply contrast enhancement (~15 lines)
            using (var enhanced = EnhanceContrast(grayscale))
            {
                // Step 4: Binarize — convert to black and white (~15 lines)
                using (var binarized = Binarize(enhanced, 128))
                {
                    // Step 5: Remove noise (~25 lines)
                    using (var denoised = RemoveNoise(binarized))
                    {
                        // Step 6: Déclin if rotated (~50 lines, simplified)
                        using (var deskewed = Deskew(denoised))
                        {
                            // Step 7: Scale to 300 DPI (~20 lines)
                            using (var scaled = ScaleToDpi(deskewed, 300))
                            {
                                return RunTesseract(scaled);  // Save to temp file, load Pix, process
                            }
                        }
                    }
                }
            }
        }
    }
}

Imports System.Drawing

Public Class ImageProcessor
    ' Tesseract requires every one of these steps to be written manually
    Public Shared Function ExtractWithPreprocessing(imagePath As String) As String
        Using original As New Bitmap(imagePath)
            ' Step 2: Convert to grayscale (~25 lines)
            Using grayscale As Bitmap = ConvertToGrayscale(original)
                ' Step 3: Apply contrast enhancement (~15 lines)
                Using enhanced As Bitmap = EnhanceContrast(grayscale)
                    ' Step 4: Binarize — convert to black and white (~15 lines)
                    Using binarized As Bitmap = Binarize(enhanced, 128)
                        ' Step 5: Remove noise (~25 lines)
                        Using denoised As Bitmap = RemoveNoise(binarized)
                            ' Step 6: Déclin if rotated (~50 lines, simplified)
                            Using deskewed As Bitmap = Deskew(denoised)
                                ' Step 7: Scale to 300 DPI (~20 lines)
                                Using scaled As Bitmap = ScaleToDpi(deskewed, 300)
                                    Return RunTesseract(scaled)  ' Save to temp file, load Pix, process
                                End Using
                            End Using
                        End Using
                    End Using
                End Using
            End Using
        End Using
    End Function

    ' Placeholder methods for image processing steps
    Private Shared Function ConvertToGrayscale(original As Bitmap) As Bitmap
        ' Implementation here
        Return Nothing
    End Function

    Private Shared Function EnhanceContrast(grayscale As Bitmap) As Bitmap
        ' Implementation here
        Return Nothing
    End Function

    Private Shared Function Binarize(enhanced As Bitmap, threshold As Integer) As Bitmap
        ' Implementation here
        Return Nothing
    End Function

    Private Shared Function RemoveNoise(binarized As Bitmap) As Bitmap
        ' Implementation here
        Return Nothing
    End Function

    Private Shared Function Deskew(denoised As Bitmap) As Bitmap
        ' Implementation here
        Return Nothing
    End Function

    Private Shared Function ScaleToDpi(deskewed As Bitmap, dpi As Integer) As Bitmap
        ' Implementation here
        Return Nothing
    End Function

    Private Shared Function RunTesseract(scaled As Bitmap) As String
        ' Implementation here
        Return String.Empty
    End Function
End Class

Cette structure imbriquée using n'est pas du boilerplate — chaque étape est une implémentation réelle : une matrice de couleurs pour le niveaux de gris, une itération de pixels pour le contraste, une autre itération de pixels pour la binarisation, un filtre médian pour le bruit et un substitut de transformée de Hough pour le désalignement. Les notes sources image-preprocessing-tesseract.cs directement : " Désalignement simplifié — une véritable implémentation nécessite une transformée de Hough. Cela nécessite généralement OpenCV ou une bibliothèque similaire.

Au total : environ 180 lignes avant qu'un seul mot ne soit lu. Le tableau de précision de ce même fichier montre pourquoi cet investissement est nécessaire : Tesseract, sans prétraitement sur un document asymétrique de 5 degrés, produit une précision de 60 à 70 %, tandis qu'une entrée correctement prétraitée atteint plus de 90 %.

Comparaison détaillée des fonctionnalités

Approche Tesseract

Le pipeline de prétraitement complet affiché dans image-preprocessing-tesseract.cs nécessite System.Drawing.Common (Windows seulement) ou une bibliothèque multiplateforme supplémentaire comme ImageSharp. La seule implémentation de désalignement note qu'elle est simplifiée — un algorithme de détection de désalignement de qualité production nécessite une transformée de ligne de Hough, ce qui implique généralement l'intégration d'OpenCvSharp4 comme dépendance supplémentaire :

// image-preprocessing-tesseract.cs — the actual implementation pattern
private static Bitmap ConvertToGrayscale(Bitmap original)
{
    var result = new Bitmap(original.Width, original.Height);
    using (var graphics = Graphics.FromImage(result))
    {
        var colorMatrix = new ColorMatrix(new float[][]
        {
            new float[] { 0.299f, 0.299f, 0.299f, 0, 0 },
            new float[] { 0.587f, 0.587f, 0.587f, 0, 0 },
            new float[] { 0.114f, 0.114f, 0.114f, 0, 0 },
            new float[] { 0, 0, 0, 1, 0 },
            new float[] { 0, 0, 0, 0, 1 }
        });
        using (var attributes = new ImageAttributes())
        {
            attributes.SetColorMatrix(colorMatrix);
            graphics.DrawImage(original,
                new Rectangle(0, 0, original.Width, original.Height),
                0, 0, original.Width, original.Height,
                GraphicsUnit.Pixel, attributes);
        }
    }
    return result;
}

private static Bitmap EnhanceContrast(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    float contrast = 1.5f;
    for (int y = 0; y < image.Height; y++)
    {
        for (int x = 0; x < image.Width; x++)
        {
            var pixel = image.GetPixel(x, y);
            int r = Clamp((int)((pixel.R - 128) * contrast + 128));
            int g = Clamp((int)((pixel.G - 128) * contrast + 128));
            int b = Clamp((int)((pixel.B - 128) * contrast + 128));
            result.SetPixel(x, y, Color.FromArgb(r, g, b));
        }
    }
    return result;
}

private static Bitmap RemoveNoise(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    int kernelSize = 3;
    int radius = kernelSize / 2;
    for (int y = radius; y < image.Height - radius; y++)
    {
        for (int x = radius; x < image.Width - radius; x++)
        {
            var pixels = new List<int>();
            for (int ky = -radius; ky <= radius; ky++)
                for (int kx = -radius; kx <= radius; kx++)
                    pixels.Add(image.GetPixel(x + kx, y + ky).R);
            pixels.Sort();
            int median = pixels[pixels.Count / 2];
            result.SetPixel(x, y, Color.FromArgb(median, median, median));
        }
    }
    return result;
}

// After all preprocessing, save to temp file — Tesseract requires a file path
private static string RunTesseract(Bitmap preprocessed)
{
    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        preprocessed.Save(tempPath, ImageFormat.Png);
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        using (var img = Pix.LoadFromFile(tempPath))
        using (var page = engine.Process(img))
            return page.GetText();
    }
    finally
    {
        if (File.Exists(tempPath)) File.Delete(tempPath);
    }
}

// image-preprocessing-tesseract.cs — the actual implementation pattern
private static Bitmap ConvertToGrayscale(Bitmap original)
{
    var result = new Bitmap(original.Width, original.Height);
    using (var graphics = Graphics.FromImage(result))
    {
        var colorMatrix = new ColorMatrix(new float[][]
        {
            new float[] { 0.299f, 0.299f, 0.299f, 0, 0 },
            new float[] { 0.587f, 0.587f, 0.587f, 0, 0 },
            new float[] { 0.114f, 0.114f, 0.114f, 0, 0 },
            new float[] { 0, 0, 0, 1, 0 },
            new float[] { 0, 0, 0, 0, 1 }
        });
        using (var attributes = new ImageAttributes())
        {
            attributes.SetColorMatrix(colorMatrix);
            graphics.DrawImage(original,
                new Rectangle(0, 0, original.Width, original.Height),
                0, 0, original.Width, original.Height,
                GraphicsUnit.Pixel, attributes);
        }
    }
    return result;
}

private static Bitmap EnhanceContrast(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    float contrast = 1.5f;
    for (int y = 0; y < image.Height; y++)
    {
        for (int x = 0; x < image.Width; x++)
        {
            var pixel = image.GetPixel(x, y);
            int r = Clamp((int)((pixel.R - 128) * contrast + 128));
            int g = Clamp((int)((pixel.G - 128) * contrast + 128));
            int b = Clamp((int)((pixel.B - 128) * contrast + 128));
            result.SetPixel(x, y, Color.FromArgb(r, g, b));
        }
    }
    return result;
}

private static Bitmap RemoveNoise(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    int kernelSize = 3;
    int radius = kernelSize / 2;
    for (int y = radius; y < image.Height - radius; y++)
    {
        for (int x = radius; x < image.Width - radius; x++)
        {
            var pixels = new List<int>();
            for (int ky = -radius; ky <= radius; ky++)
                for (int kx = -radius; kx <= radius; kx++)
                    pixels.Add(image.GetPixel(x + kx, y + ky).R);
            pixels.Sort();
            int median = pixels[pixels.Count / 2];
            result.SetPixel(x, y, Color.FromArgb(median, median, median));
        }
    }
    return result;
}

// After all preprocessing, save to temp file — Tesseract requires a file path
private static string RunTesseract(Bitmap preprocessed)
{
    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        preprocessed.Save(tempPath, ImageFormat.Png);
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        using (var img = Pix.LoadFromFile(tempPath))
        using (var page = engine.Process(img))
            return page.GetText();
    }
    finally
    {
        if (File.Exists(tempPath)) File.Delete(tempPath);
    }
}

Imports System.Drawing
Imports System.Drawing.Imaging
Imports Tesseract
Imports System.IO

' image-preprocessing-tesseract.vb — the actual implementation pattern
Private Shared Function ConvertToGrayscale(original As Bitmap) As Bitmap
    Dim result As New Bitmap(original.Width, original.Height)
    Using graphics As Graphics = Graphics.FromImage(result)
        Dim colorMatrix As New ColorMatrix(New Single()() {
            New Single() {0.299F, 0.299F, 0.299F, 0, 0},
            New Single() {0.587F, 0.587F, 0.587F, 0, 0},
            New Single() {0.114F, 0.114F, 0.114F, 0, 0},
            New Single() {0, 0, 0, 1, 0},
            New Single() {0, 0, 0, 0, 1}
        })
        Using attributes As New ImageAttributes()
            attributes.SetColorMatrix(colorMatrix)
            graphics.DrawImage(original, New Rectangle(0, 0, original.Width, original.Height), 0, 0, original.Width, original.Height, GraphicsUnit.Pixel, attributes)
        End Using
    End Using
    Return result
End Function

Private Shared Function EnhanceContrast(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim contrast As Single = 1.5F
    For y As Integer = 0 To image.Height - 1
        For x As Integer = 0 To image.Width - 1
            Dim pixel As Color = image.GetPixel(x, y)
            Dim r As Integer = Clamp(CInt((pixel.R - 128) * contrast + 128))
            Dim g As Integer = Clamp(CInt((pixel.G - 128) * contrast + 128))
            Dim b As Integer = Clamp(CInt((pixel.B - 128) * contrast + 128))
            result.SetPixel(x, y, Color.FromArgb(r, g, b))
        Next
    Next
    Return result
End Function

Private Shared Function RemoveNoise(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim kernelSize As Integer = 3
    Dim radius As Integer = kernelSize \ 2
    For y As Integer = radius To image.Height - radius - 1
        For x As Integer = radius To image.Width - radius - 1
            Dim pixels As New List(Of Integer)()
            For ky As Integer = -radius To radius
                For kx As Integer = -radius To radius
                    pixels.Add(image.GetPixel(x + kx, y + ky).R)
                Next
            Next
            pixels.Sort()
            Dim median As Integer = pixels(pixels.Count \ 2)
            result.SetPixel(x, y, Color.FromArgb(median, median, median))
        Next
    Next
    Return result
End Function

' After all preprocessing, save to temp file — Tesseract requires a file path
Private Shared Function RunTesseract(preprocessed As Bitmap) As String
    Dim tempPath As String = Path.GetTempFileName() & ".png"
    Try
        preprocessed.Save(tempPath, ImageFormat.Png)
        Using engine As New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            Using img As Pix = Pix.LoadFromFile(tempPath)
                Using page As Page = engine.Process(img)
                    Return page.GetText()
                End Using
            End Using
        End Using
    Finally
        If File.Exists(tempPath) Then File.Delete(tempPath)
    End Try
End Function

Private Shared Function Clamp(value As Integer) As Integer
    Return Math.Max(0, Math.Min(255, value))
End Function

Private Const TessDataPath As String = "path_to_tessdata" ' Define the path to tessdata directory

Il s'agit du code réel issu des fichiers sources — et non d'un scénario catastrophe artificiel. L'approche d'itération de pixel pour la suppression du contraste et du bruit s'exécute en O(n²) sur chaque pixel. L'enregistrement et le chargement du fichier temporaire ne sont pas optionnels ; Pix.LoadFromFile nécessite un chemin de fichier sur le disque. Pour une application traitant 1 000 documents numérisés par jour, cela représente une surcharge mesurable qui s'ajoute au temps de reconnaissance optique de caractères (OCR).

Approche d'IronOCR

Le même prétraitement dans IronOCR est une séquence d'appels de méthode sur OcrInput :

// dotnet add package IronOcr
using IronOcr;

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();           // Detects and corrects skew angle automatically
input.DeNoise();          // Removes scanner artifacts and specks
input.Contrast();         // Enhances contrast for character separation
input.Binarize();         // Converts to black and white with adaptive threshold
input.EnhanceResolution(300);  // Scales to 300 DPI for optimal recognition

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");
Console.WriteLine(result.Text);

// dotnet add package IronOcr
using IronOcr;

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();           // Detects and corrects skew angle automatically
input.DeNoise();          // Removes scanner artifacts and specks
input.Contrast();         // Enhances contrast for character separation
input.Binarize();         // Converts to black and white with adaptive threshold
input.EnhanceResolution(300);  // Scales to 300 DPI for optimal recognition

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");
Console.WriteLine(result.Text);

Imports IronOcr

Dim input As New OcrInput()
input.LoadImage("low-quality-scan.jpg")

input.Deskew()           ' Detects and corrects skew angle automatically
input.DeNoise()          ' Removes scanner artifacts and specks
input.Contrast()         ' Enhances contrast for character separation
input.Binarize()         ' Converts to black and white with adaptive threshold
input.EnhanceResolution(300)  ' Scales to 300 DPI for optimal recognition

Using input
    Dim result = New IronTesseract().Read(input)
    Console.WriteLine($"Confidence: {result.Confidence}%")
    Console.WriteLine(result.Text)
End Using

Aucun fichier temporaire. Aucune itération de pixel. Aucune dépendance à System.Drawing.Common ou OpenCvSharp4. Le guide de correction de la qualité d'image et le guide de correction de l'orientation d'image couvrent l'intégralité du catalogue de filtres — plus de 15 sont disponibles. L' exemple des filtres d'image illustre le processus de numérisation de basse qualité de bout en bout.

Pour la plupart des documents réels, la lecture par défaut applique un prétraitement automatique intelligent sans aucun appel de filtre explicite :

// Automatic preprocessing applied internally — no explicit filter calls needed
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

// Automatic preprocessing applied internally — no explicit filter calls needed
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

Imports IronTesseract

' Automatic preprocessing applied internally — no explicit filter calls needed
Dim text As String = New IronTesseract().Read("scanned-invoice.jpg").Text

Sur une entrée propre et à haute résolution, cela ne coûte rien. Sur une photo prise avec un téléphone portable à 72 DPI, le moteur effectue une mise à l'échelle, une amélioration et une normalisation avant de reconnaître le texte.

Approche Tesseract

Le fichier pdf-ocr-processing-tesseract.cs documente trois options de bibliothèque de rendu PDF distinctes — PdfiumViewer, PDFtoImage et Docnet.Core — chacune avec des chaînes de dépendance et des compromis différents. Le modèle PdfiumViewer présenté dans ce fichier est représentatif :

// Tesseract PDF processing — from pdf-ocr-processing-tesseract.cs
// Requires: PdfiumViewer NuGet + pdfium native DLL deployed to application directory
// NuGet: PdfiumViewer, PdfiumViewer.Native.x64

using PdfiumViewer;

public static string ExtractFromPdfWithPdfium(string pdfPath)
{
    var results = new List<string>();

    using (var document = PdfDocument.Load(pdfPath))
    {
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        {
            for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
            {
                // Render page to image at 300 DPI
                using (var pageImage = document.Render(pageIndex, 300, 300,
                    PdfRenderFlags.CorrectFromDpi))
                {
                    // Tesseract requires a file path — must write to disk first
                    string tempPath = Path.GetTempFileName() + ".png";
                    try
                    {
                        pageImage.Save(tempPath);
                        using (var img = Pix.LoadFromFile(tempPath))
                        using (var page = engine.Process(img))
                            results.Add(page.GetText());
                    }
                    finally
                    {
                        File.Delete(tempPath);  // Must clean up or disk fills
                    }
                }
            }
        }
    }

    return string.Join("\n\n--- Page Break ---\n\n", results);
}

// Tesseract PDF processing — from pdf-ocr-processing-tesseract.cs
// Requires: PdfiumViewer NuGet + pdfium native DLL deployed to application directory
// NuGet: PdfiumViewer, PdfiumViewer.Native.x64

using PdfiumViewer;

public static string ExtractFromPdfWithPdfium(string pdfPath)
{
    var results = new List<string>();

    using (var document = PdfDocument.Load(pdfPath))
    {
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        {
            for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
            {
                // Render page to image at 300 DPI
                using (var pageImage = document.Render(pageIndex, 300, 300,
                    PdfRenderFlags.CorrectFromDpi))
                {
                    // Tesseract requires a file path — must write to disk first
                    string tempPath = Path.GetTempFileName() + ".png";
                    try
                    {
                        pageImage.Save(tempPath);
                        using (var img = Pix.LoadFromFile(tempPath))
                        using (var page = engine.Process(img))
                            results.Add(page.GetText());
                    }
                    finally
                    {
                        File.Delete(tempPath);  // Must clean up or disk fills
                    }
                }
            }
        }
    }

    return string.Join("\n\n--- Page Break ---\n\n", results);
}

Imports PdfiumViewer
Imports Tesseract

Public Shared Function ExtractFromPdfWithPdfium(pdfPath As String) As String
    Dim results As New List(Of String)()

    Using document = PdfDocument.Load(pdfPath)
        Using engine = New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            For pageIndex As Integer = 0 To document.PageCount - 1
                ' Render page to image at 300 DPI
                Using pageImage = document.Render(pageIndex, 300, 300, PdfRenderFlags.CorrectFromDpi)
                    ' Tesseract requires a file path — must write to disk first
                    Dim tempPath As String = Path.GetTempFileName() & ".png"
                    Try
                        pageImage.Save(tempPath)
                        Using img = Pix.LoadFromFile(tempPath)
                            Using page = engine.Process(img)
                                results.Add(page.GetText())
                            End Using
                        End Using
                    Finally
                        File.Delete(tempPath)  ' Must clean up or disk fills
                    End Try
                End Using
            Next
        End Using
    End Using

    Return String.Join(vbCrLf & vbCrLf & "--- Page Break ---" & vbCrLf & vbCrLf, results)
End Function

La source pdf-ocr-processing-tesseract.cs note directement la chaîne de dépendance : " Tesseract : Apache 2.0, PdfiumViewer : BSD, iText : AGPL ou commercial, GhostScript : AGPL ou commercial. " Ce dernier point est important dans les contextes d'entreprise — la licence AGPL de GhostScript exige que votre application soit open-source, sauf si vous achetez une licence GhostScript commerciale.

Les PDF protégés par mot de passe ajoutent une couche supplémentaire. La classe PasswordProtectedPdf dans le même fichier génère NotImplementedException avec le commentaire : " Nécessite une bibliothèque PDF avec support de chiffrement (iText, PDFSharp). Tesseract ne peut pas déchiffrer les fichiers PDF. La protection par mot de passe implique donc une quatrième dépendance avec ses propres considérations de licence.

Approche d'IronOCR

IronOCR lit nativement les fichiers PDF, y compris les PDF numérisés, les PDF de texte numérique, les PDF à contenu mixte et les PDF protégés par mot de passe :

// dotnet add package IronOcr
using IronOcr;

// Scanned PDF — direct load, no rendering library required
var result = new IronTesseract().Read("scanned-contract.pdf");
Console.WriteLine(result.Text);

// Password-protected PDF — one additional parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var protectedResult = new IronTesseract().Read(input);

// Specific page range from a 200-page document
using var rangeInput = new OcrInput();
rangeInput.LoadPdfPages("large-report.pdf", 1, 10);
var rangeResult = new IronTesseract().Read(rangeInput);

// Create searchable PDF with embedded text layer
var searchable = new IronTesseract().Read("scanned-invoice.pdf");
searchable.SaveAsSearchablePdf("searchable-invoice.pdf");

// dotnet add package IronOcr
using IronOcr;

// Scanned PDF — direct load, no rendering library required
var result = new IronTesseract().Read("scanned-contract.pdf");
Console.WriteLine(result.Text);

// Password-protected PDF — one additional parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var protectedResult = new IronTesseract().Read(input);

// Specific page range from a 200-page document
using var rangeInput = new OcrInput();
rangeInput.LoadPdfPages("large-report.pdf", 1, 10);
var rangeResult = new IronTesseract().Read(rangeInput);

// Create searchable PDF with embedded text layer
var searchable = new IronTesseract().Read("scanned-invoice.pdf");
searchable.SaveAsSearchablePdf("searchable-invoice.pdf");

Imports IronOcr

' Scanned PDF — direct load, no rendering library required
Dim result = New IronTesseract().Read("scanned-contract.pdf")
Console.WriteLine(result.Text)

' Password-protected PDF — one additional parameter
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret")
    Dim protectedResult = New IronTesseract().Read(input)
End Using

' Specific page range from a 200-page document
Using rangeInput As New OcrInput()
    rangeInput.LoadPdfPages("large-report.pdf", 1, 10)
    Dim rangeResult = New IronTesseract().Read(rangeInput)
End Using

' Create searchable PDF with embedded text layer
Dim searchable = New IronTesseract().Read("scanned-invoice.pdf")
searchable.SaveAsSearchablePdf("searchable-invoice.pdf")

Aucune bibliothèque de rendu PDF. Aucun fichier temporaire. Aucune considération relative à la licence AGPL. Le guide pratique d'importation de fichiers PDF couvre toutes les variantes d'importation de fichiers PDF. Le guide PDF consultable explique la sortie de la couche texte. Pour les équipes qui développent des pipelines de traitement de documents, la page de cas d'utilisation de la reconnaissance optique de caractères (OCR) PDF fournit des modèles d'architecture de production.

Les méthodes de prétraitement fonctionnent de manière identique sur l'entrée PDF, permettant les mêmes appels input.Deskew(), input.DeNoise(), input.EnhanceResolution() sur les PDF numérisés sans aucune étape de conversion intermédiaire.

Approche Tesseract

Le fichier multi-language-tesseract.cs documente les tailles et le processus de gestion de fichiers de langue :

// Must exist before initialization:
// ./tessdata/eng.traineddata   (~15 MB)
// ./tessdata/fra.traineddata   (~15 MB)
// ./tessdata/deu.traineddata   (~15 MB)
// ./tessdata/chi_sim.traineddata  (~45 MB)
// ./tessdata/jpn.traineddata   (~40 MB)
// 10 languages = 200-300 MB to download and manage

public string SafeMultiLanguageOcr(string imagePath, string[] languages)
{
    // Check presence before attempting — runtime failures are worse
    foreach (var lang in languages)
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
        {
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
        }
    }

    var langString = string.Join("+", languages);  // e.g., "eng+fra+deu"
    using var engine = new TesseractEngine(TessDataPath, langString, EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);
    return page.GetText();
}

// Must exist before initialization:
// ./tessdata/eng.traineddata   (~15 MB)
// ./tessdata/fra.traineddata   (~15 MB)
// ./tessdata/deu.traineddata   (~15 MB)
// ./tessdata/chi_sim.traineddata  (~45 MB)
// ./tessdata/jpn.traineddata   (~40 MB)
// 10 languages = 200-300 MB to download and manage

public string SafeMultiLanguageOcr(string imagePath, string[] languages)
{
    // Check presence before attempting — runtime failures are worse
    foreach (var lang in languages)
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
        {
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
        }
    }

    var langString = string.Join("+", languages);  // e.g., "eng+fra+deu"
    using var engine = new TesseractEngine(TessDataPath, langString, EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);
    return page.GetText();
}

Imports System.IO
Imports Tesseract

Public Function SafeMultiLanguageOcr(imagePath As String, languages As String()) As String
    ' Check presence before attempting — runtime failures are worse
    For Each lang In languages
        If Not File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")) Then
            Throw New FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " &
                "Download from https://github.com/tesseract-ocr/tessdata")
        End If
    Next

    Dim langString = String.Join("+", languages)  ' e.g., "eng+fra+deu"
    Using engine As New TesseractEngine(TessDataPath, langString, EngineMode.Default)
        Using img As Pix = Pix.LoadFromFile(imagePath)
            Using page As Page = engine.Process(img)
                Return page.GetText()
            End Using
        End Using
    End Using
End Function

La vérification défensive de l'existence des fichiers n'est pas une paranoïa — un fichier .traineddata manquant déclenche TesseractException: Failed to initialise tesseract engine avec un message qui n'identifie pas toujours clairement quel fichier est manquant. La source basic-text-extraction-tesseract.cs documente les exceptions d'exécution courantes : System.DllNotFoundException pour les binaires Leptonica manquants, TesseractException pour les tessdata manquants, BadImageFormatException pour les incohérences de 32/64 bits.

Dans les déploiements Docker, les fichiers tessdata doivent être copiés dans l'image du conteneur. Pour trois langues à 15 Mo chacune plus les modèles best à 50-100 Mo chacun, les images de conteneur augmentent de plusieurs centaines de mégaoctets. Les pipelines CI/CD doivent soit mettre en cache ces téléchargements, soit accepter des temps de compilation lents lorsque le cache est froid.

Approche d'IronOCR

La prise en charge des langues dans IronOCR est référencée dans le package NuGet :

// Install once: dotnet add package IronOcr.Languages.French
// Install once: dotnet add package IronOcr.Languages.German
using IronOcr;

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);

var result = ocr.Read("multilingual-document.jpg");

// Install once: dotnet add package IronOcr.Languages.French
// Install once: dotnet add package IronOcr.Languages.German
using IronOcr;

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);

var result = ocr.Read("multilingual-document.jpg");

Imports IronOcr

' Install once: dotnet add package IronOcr.Languages.French
' Install once: dotnet add package IronOcr.Languages.German

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.French
ocr.AddSecondaryLanguage(OcrLanguage.German)

Dim result = ocr.Read("multilingual-document.jpg")

Les données linguistiques sont intégrées au package NuGet . Aucun dossier à créer, aucun chemin à configurer, aucun fichier à télécharger depuis GitHub et à vérifier. Ajouter une langue à Dockersignifie ajouter une ligne PackageReference au .csproj. Le guide pratique multilingue couvre l'intégralité du catalogue de plus de 125 langues, et l' article de blog multilingue décrit les pipelines de production multilingues, y compris les jeux de caractères CJK.

L'étape de prétraitement est atteinte

Chaque projet Tesseract commence par des images de test propres. Exemples de factures, documents scannés avec précision, fichiers PNG à 300 DPI fonctionnant dès la première lecture. La question du prétraitement est reportée. Puis arrive le premier lot de production : des bons de commande faxés à 150 DPI, des contrats scannés avec une inclinaison de 3 degrés, des photographies de reçus prises sous un éclairage fluorescent. La précision chute à 60-70 %. L'équipe doit maintenant mettre en œuvre le pipeline de prétraitement qui avait été reporté, et découvre que la conversion en niveaux de gris et l'amélioration du contraste sont gérables, mais que le redressement nécessite une transformation de Hough et la réduction du bruit un filtre médian, et qu'aucune des deux tâches ne prend deux heures. Les équipes à cette étape — où la dette de prétraitement devient un élément de backlog sprint — évaluent fréquemment IronOCR parce que le coût de la licence est moins cher que deux semaines de travail de traitement d'image qu'ils n'ont pas été embauchés pour réaliser.

L'exigence PDF apparaît

Les applications de traitement de documents ont presque toujours besoin, à terme, de la prise en charge du format PDF. La première réponse est généralement " ajouter PdfiumViewer " — il est bien documenté et gère bien de nombreux cas. Les problèmes émergent en production : le pdfium.dll natif doit être présent dans le répertoire de l'application à la bonne architecture, les images de conteneur nécessitent des étapes COPY explicites dans les Dockerfiles, les déploiements Linuxont besoin du fichier correspondant .so, et les PDF protégés par mot de passe nécessitent une bibliothèque de décryptage séparée avec sa propre licence. Les équipes qui gèrent trois chaînes de dépendances distinctes — les bibliothèques natives de Tesseract, Leptonica et pdfium — dans quatre environnements (Windows, Linux, Docker, CI) atteignent un seuil de maintenance où une alternative à package unique devient intéressante à évaluer.

Traitement parallèle à grande échelle

Un traitement par lots de 500 factures par reconnaissance optique de caractères (OCR) bénéficie du parallélisme. Avec le wrapper charlesw, le modèle de traitement parallèle sécurisé crée une instance de moteur par thread, chargeant chacune 40 à 100 Mo de données de modèle de langage. Avec huit threads, cela représente 320 à 800 Mo de mémoire moteur avant même le chargement des documents. Les équipes qui analysent leurs services OCR et constatent que la pression sur la mémoire se concentre lors de l'initialisation du moteur — plutôt que sur le contenu du document — trouvent que le modèle à instance unique et thread-safe d'IronOCR s'attaque directement à la cause profonde. L' exemple de multithreading illustre ce modèle.

Les environnements de déploiement se multiplient

Un projet initialement développé sous Fenêtresajoute un conteneur Linuxpour le déploiement dans le cloud. Le Dockerfile nécessite désormais des étapes d'installation de bibliothèques natives, les fichiers tessdata doivent être copiés dans le conteneur et la variable d'environnement du chemin tessdata doit être correctement définie. Puis un développeur macOSrejoint l'équipe. Ensuite, quelqu'un souhaite déployer sur AWS Lambda. Chaque plateforme ajoute une surface de configuration supplémentaire susceptible de dysfonctionner silencieusement : l'absence d'une bibliothèque native lors de l'exécution dans un conteneur de production est plus problématique qu'un coût légèrement supérieur pour les packages NuGet . Le guide de déploiement Docker IronOCR illustre ce contraste : aucun package système, aucune étape de copie de tessdata, aucune variable d'environnement.

La devise de la version de Tesseract est importante

Tesseract 5.x a introduit des améliorations de la précision LSTM mesurables sur certains types de documents. Le wrapper charlesw cible Tesseract 4.1.1. Pour les équipes pour lesquelles la précision de la reconnaissance optique de caractères (OCR) sur des documents complexes est un critère de qualité produit, l'écart de version est un facteur important, surtout lorsque l'alternative est un progiciel commercial mis à jour avec la version actuelle du moteur.

Suppression du dossier Tessdata

La première étape de nettoyage après la migration vers IronOCR est de supprimer le dossier tessdata et de retirer les éléments correspondants <Content Include="tessdata\**"> du fichier projet. Tout code de validation de chemin hardcodé — la protection Directory.Exists(TessDataPath) présente dans basic-text-extraction-tesseract.cs — disparaît également. Les références de l'espace de noms using Tesseract; et les références de type TesseractEngine, Pix, et Page doivent toutes être remplacées par using IronOcr;, IronTesseract, OcrInput, et OcrResult.

Suppression de la bibliothèque PDF

Toute bibliothèque de rendu PDF ajoutée uniquement pour prendre en charge le traitement PDF Tesseract (PdfiumViewer, PDFtoImage, Docnet.Core) peut être supprimée. Les dépendances binaires natives requises par ces paquets (pdfium.dll, binaires GhostScript) disparaissent également. Les lignes Dockerfile COPY et apt-get pour ces dépendances ne sont plus nécessaires. Le guide d'entrée PDF IronOCR couvre toutes les variantes d'entrée PDF prises en charge par ces bibliothèques, y compris la sélection de plages de pages et les documents protégés par mot de passe. Tout le bloc de rendu-puis-OCR — généralement 50-80 lignes s'étendant sur trois bibliothèques — se réduit à input.LoadPdf(path) suivi d'un seul appel Read().

Remplacement du code de prétraitement

Les méthodes de prétraitement existantes — ConvertToGrayscale, EnhanceContrast, Binarize, RemoveNoise, Deskew, ScaleToDpi — se correspondent directement aux méthodes de filtre d'IronOCR. Le système d'enregistrement et de chargement de fichiers temporaires disparaît complètement. Consultez le guide de correction des couleurs d'image pour les transformations spécifiques aux couleurs et le guide des paramètres DPI pour la gestion de la résolution.

Modification du modèle de fil

Le code qui crée TesseractEngine à l'intérieur d'une boucle Parallel.ForEach — un par thread — change pour créer IronTesseract une fois avant la boucle et le partager entre tous les threads. Il s'agit d'une modification de correction, et non d'une simple refactorisation : l'ancien modèle consistait en une programmation défensive autour d'une API non sécurisée pour les threads ; Le nouveau modèle correspond à l'utilisation prévue d'une API thread-safe. La surcharge d'initialisation du moteur par thread (40 à 100 Mo de données de modèle de langage par thread) disparaît grâce à cette modification, car IronOCR utilise un pool interne partagé au lieu de charger l'état complet du modèle pour chaque instance du moteur.