OCR-API Microsoft Azure Vision vs. IronOCR: Welche verarbeitet Dokumentenbilder besser?

Die Vorverarbeitungslücke

Die Vorverarbeitungsanforderung ist keine Konfigurationsoption, auf die man verzichten kann. Sie entscheidet über die Genauigkeit der Ergebnisse in der Produktion und die Unbrauchbarkeit der Ergebnisse bei realen Dokumenten. Die image-preprocessing-tesseract.cs Quelldatei für diesen Wrapper dokumentiert das vollständige manuelle Pipeline:

// 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: Entschiefen 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: Entschiefen 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
    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: Entschiefen 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 Nothing
    End Function
End Class

Diese verschachtelte using Struktur ist kein Standard – jeder Schritt ist eine echte Implementierung: eine Farbmatrix für Graustufen, Pixeliteration für Kontrast, eine weitere Pixeliteration für Binarisierung, ein Medianfilter für Rauschen und ein Hough-Transformationsersatz zum Entzerren. Die image-preprocessing-tesseract.cs Quelle vermerkt direkt: "Vereinfachtes Entzerren — Eine echte Implementierung benötigt Hough-Transformation. Hierfür wird typischerweise OpenCV oder eine ähnliche Bibliothek benötigt."

Insgesamt: ungefähr 180 Zeilen, bevor ein einziges Wort gelesen wird. Die Genauigkeitstabelle in derselben Datei zeigt, warum die Investition notwendig ist – Tesseract ohne Vorverarbeitung erzielt bei einem um 5 Grad geneigten Dokument eine Genauigkeit von 60-70 %, während bei ordnungsgemäß vorverarbeiteten Eingaben eine Genauigkeit von über 90 % erreicht wird.

Detaillierter Funktionsvergleich

Tesserakt-Ansatz

Die komplette Vorverarbeitungspipeline, die in image-preprocessing-tesseract.cs gezeigt wird, erfordert System.Drawing.Common (nur Windows) oder eine zusätzliche plattformübergreifende Bibliothek wie ImageSharp. Die Entzerrungsimplementierung allein merkt an, dass sie vereinfacht ist – ein produktionsreifes Schieferkennungsalgorithmus erfordert eine Hough-Linien-Transformation, was typischerweise bedeutet, OpenCvSharp4 als zusätzliche Abhängigkeit hinzuzuziehen:

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

Dies ist echter Code aus den Quelldateien – kein konstruiertes Worst-Case-Szenario. Der Pixel-Iterationsansatz zur Kontrast- und Rauschunterdrückung hat eine Laufzeit von O(n²) über jedes Pixel. Das Speichern und Laden der temporären Datei ist nicht optional; Pix.LoadFromFile erfordert einen Dateipfad auf der Festplatte. Bei einer Anwendung, die 1.000 gescannte Dokumente pro Tag verarbeitet, stellt dies einen messbaren Mehraufwand zusätzlich zur OCR-Zeit dar.

IronOCR-Ansatz

Die gleiche Vorverarbeitung in IronOCR ist eine Abfolge von Methodenaufrufen auf 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

Keine temporären Dateien. Keine Pixeliteration. Keine Abhängigkeit von System.Drawing.Common oder OpenCvSharp4. Die Anleitungen zur Bildqualitätskorrektur und zur Bildorientierungskorrektur decken den gesamten Filterkatalog ab – es stehen über 15 Filter zur Verfügung. Das Beispiel der Bildfilter zeigt den gesamten Ablauf einer Scan-Pipeline mit niedriger Qualität.

Bei den meisten realen Dokumenten wird standardmäßig eine intelligente automatische Vorverarbeitung ohne jegliche explizite Filteraufrufe angewendet:

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

Bei sauberer, hochauflösender Eingabe kostet dies nichts. Bei einem 72-DPI-Foto eines Smartphones skaliert, verbessert und normalisiert die Engine das Bild, bevor sie den Text erkennt.

Tesserakt-Ansatz

Die pdf-ocr-processing-tesseract.cs Datei dokumentiert drei separate PDF-Rendering-Bibliotheksoptionen – PdfiumViewer, PDFtoImage und Docnet.Core – jede mit unterschiedlichen Abhängigkeitsketten und Kompromissen. Das in dieser Datei gezeigte PdfiumViewer-Muster ist repräsentativ:

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

Die pdf-ocr-processing-tesseract.cs Quelle vermerkt direkt die Abhängigkeit: "Tesseract: Apache 2.0, PdfiumViewer: BSD, iText: AGPL oder kommerziell, GhostScript: AGPL oder kommerziell." Letzterer Punkt ist in Unternehmenskontexten wichtig – GhostScripts AGPL-Lizenz erfordert, dass Ihre Anwendung Open-Source ist, es sei denn, Sie kaufen eine kommerzielle GhostScript-Lizenz.

Passwortgeschützte PDFs fügen eine weitere Sicherheitsebene hinzu. Die PasswordProtectedPdf Klasse in derselben Datei wirft NotImplementedException mit dem Kommentar: "Erfordert PDF-Bibliothek mit Verschlüsselungsunterstützung (iText, PDFSharp). Tesseract kann keine PDFs entschlüsseln." Passwortschutz bedeutet also eine vierte Abhängigkeit mit eigenen Lizenzbestimmungen.

IronOCR-Ansatz

IronOCR liest PDFs nativ, einschließlich gescannter PDFs, digitaler Text-PDFs, PDFs mit gemischtem Inhalt und passwortgeschützter PDFs:

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

Keine PDF-Rendering-Bibliothek. Keine temporären Dateien. Keine AGPL-Lizenzbestimmungen. Die Anleitung zur PDF-Eingabe deckt alle Varianten der PDF-Eingabe ab. Die durchsuchbare PDF-Anleitung erklärt die Ausgabe der Textebene. Für Teams, die Dokumentenverarbeitungspipelines aufbauen, bietet die Seite zum Anwendungsfall PDF OCR Architekturmuster für die Produktion.

Die Vorverarbeitungsmethoden funktionieren identisch bei PDF-Eingaben und ermöglichen dieselben input.Deskew(), input.DeNoise(), input.EnhanceResolution() Aufrufe auf gescannten PDFs ohne Zwischenschritt der Konvertierung.

Tesserakt-Ansatz

Die multi-language-tesseract.cs Datei dokumentiert die Sprachdateigrößen und den Verwaltungsprozess:

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

Die defensive Datei-Existenzprüfung ist keine Paranoia – eine fehlende .traineddata Datei wirft TesseractException: Failed to initialise tesseract engine mit einer Nachricht, die nicht immer deutlich sagt, welche Datei fehlt. Die basic-text-extraction-tesseract.cs Quelle dokumentiert die häufigen Laufzeitausnahmen: System.DllNotFoundException für fehlende Leptonica-Binärdateien, TesseractException für fehlende tessdata, BadImageFormatException für 32/64-Bit-Unstimmigkeiten.

Bei Docker-Bereitstellungen müssen die Tessdata-Dateien in das Container-Image kopiert werden. Für drei Sprachen à 15 MB plus die best Modelle à 50-100 MB blähen Container-Images um mehrere hundert Megabyte auf. CI/CD-Pipelines müssen diese Downloads entweder zwischenspeichern oder längere Build-Zeiten in Kauf nehmen, wenn der Cache leer ist.

IronOCR-Ansatz

Die Sprachunterstützung in IronOCR ist eine NuGet Paketreferenz:

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

Die Sprachdaten sind im NuGet Paket eingebettet. Kein Ordner muss erstellt, kein Pfad konfiguriert, keine Datei von GitHub heruntergeladen und überprüft werden. Das Hinzufügen einer Sprache zu Dockerbedeutet, eine PackageReference Zeile zur .csproj hinzuzufügen. Die Anleitung zur Mehrsprachigkeit deckt den gesamten Katalog mit über 125 Sprachen ab, und der Blogbeitrag zur Mehrsprachigkeit beschreibt Produktionspipelines für mehrere Sprachen einschließlich CJK-Zeichensätzen.

Der Meilenstein der Vorverarbeitung ist erreicht

Jedes Tesseract-Projekt beginnt mit sauberen Testabbildern. Musterrechnungen, klar gescannte Dokumente, PNG-Dateien mit 300 DPI, die beim ersten Lesen funktionieren. Die Frage der Vorverarbeitung wird vertagt. Dann trifft die erste Produktionscharge ein: gefaxte Bestellungen mit 150 DPI, gescannte Verträge mit 3-Grad-Verzerrung, Fotos von Belegen, die unter Leuchtstoffröhren aufgenommen wurden. Die Genauigkeit sinkt auf 60-70%. Das Team steht nun vor der Aufgabe, die verschobene Vorverarbeitungspipeline umzusetzen. Dabei stellt sich heraus, dass die Graustufenkonvertierung und die Kontrastverbesserung zwar machbar sind, die Entzerrung jedoch eine Hough-Transformation und die Rauschunterdrückung einen Medianfilter erfordert – beides Aufgaben, die keine zwei Stunden in Anspruch nehmen. Teams bei diesem Meilenstein — wenn die Vorverarbeitung zur Sprint-Rückstandsliste wird — evaluieren häufig IronOCR, weil die Lizenzkosten günstiger sind als zwei Entwickler-Wochen Bildverarbeitungsarbeit, die sie nicht eingestellt wurden, um zu machen.

Die PDF-Anforderung erscheint

Anwendungen zur Dokumentenverarbeitung benötigen fast immer irgendwann PDF-Unterstützung. Die erste Reaktion ist in der Regel "PdfiumViewer hinzufügen" – es ist gut dokumentiert und bewältigt viele Anwendungsfälle gut. Die Probleme zeigen sich in der Produktion: das native pdfium.dll muss im Anwendungsverzeichnis mit der richtigen Bit-Anzahl vorhanden sein, Container-Images erfordern explizite COPY-Schritte in Dockerfiles, Linux-Bereitstellungen brauchen die korrespondierende .so Datei und passwortgeschützte PDFs benötigen eine separate Entschlüsselungsbibliothek mit eigener Lizenz. Teams, die drei separate Abhängigkeitsketten verwalten – native Tesseract-Bibliotheken, Leptonica und pdfium – in vier Umgebungen (Windows, Linux, Docker, CI), erreichen einen Wartungsschwellenwert, bei dem die Prüfung einer Alternative mit nur einem Paket sinnvoll wird.

Parallelverarbeitung in großem Umfang

Ein Stapelverarbeitungsauftrag für OCR, der 500 Rechnungen verarbeitet, profitiert von Parallelverarbeitung. Mit dem CharlesW-Wrapper erzeugt das sichere Parallelverarbeitungsmuster eine Engine-Instanz pro Thread, die jeweils 40-100 MB an Sprachmodelldaten lädt. Bei acht Threads entspricht das 320-800 MB Arbeitsspeicher, bevor überhaupt Dokumente geladen werden. Teams, die ihre OCR-Dienste analysieren und feststellen, dass der Speicherdruck bei der Initialisierung der Engine konzentriert ist – und nicht beim Dokumentinhalt –, finden heraus, dass das threadsichere Einzelinstanzmodell von IronOCR die Ursache direkt angeht. Das Beispiel mit Multithreading veranschaulicht das Muster.

Einsatzumgebungen vervielfachen

Ein unter Windowsgestartetes Projekt fügt einen Linux-Container für die Cloud-Bereitstellung hinzu. Die Dockerfile benötigt nun Schritte zur Installation nativer Bibliotheken, die tessdata-Dateien müssen in den Container kopiert werden und die Umgebungsvariable für den tessdata-Pfad muss korrekt gesetzt werden. Dann stößt ein macOS-Entwickler zum Team. Dann möchte jemand die Anwendung auf AWS Lambda bereitstellen. Jede Plattform fügt eine weitere Konfigurationsoberfläche hinzu, die unbemerkt Fehler verursachen kann – eine fehlende native Bibliothek zur Laufzeit in einem Produktionscontainer ist ein schlimmeres Ergebnis als geringfügig höhere NuGet Paketkosten. Der IronOCR Docker-Bereitstellungsleitfaden verdeutlicht den Unterschied: keine Systempakete, kein Kopiervorgang für Tessdata, keine Umgebungsvariablen.

Tesseract-Version Währungsangelegenheiten

Tesseract 5.x führte Verbesserungen der LSTM-Genauigkeit ein, die bei bestimmten Dokumenttypen messbar sind. Der CharlesW-Wrapper ist für Tesseract 4.1.1 ausgelegt. Für Teams, bei denen die OCR-Genauigkeit bei schwierigen Dokumenten ein Qualitätsmerkmal ist, stellt der Versionsunterschied einen wichtigen Faktor dar – insbesondere, wenn die Alternative ein kommerziell gepflegtes Paket ist, das die aktuelle Engine-Version unterstützt.

Entfernung des Tessdata-Ordners

Der erste Bereinigungsschritt nach der Migration zu IronOCR ist das Löschen des tessdata-Ordners und das Entfernen der korrespondierenden <Content Include="tessdata\**"> Elemente aus der Projektdatei. Jedes festkodierte Pfadvalidierungscode — der Directory.Exists(TessDataPath) Wächter vorhanden in basic-text-extraction-tesseract.cs — wird ebenfalls entfernt. Die using Tesseract; Namensraumreferenzen und TesseractEngine, Pix und Page Typreferenzen müssen durch using IronOcr;, IronTesseract, OcrInput und OcrResult ersetzt werden.

Entfernung der PDF-Bibliothek

Alle PDF-Rendering-Bibliotheken, die ausschließlich zur Unterstützung der Tesseract-PDF-Verarbeitung hinzugefügt wurden – PdfiumViewer, PDFtoImage, Docnet.Core – können entfernt werden. Die nativen Binärabhängigkeiten, die diese Pakete erforderten (pdfium.dll, GhostScript-Binärdateien) entfallen ebenfalls. Dockerfile COPY und apt-get Zeilen für diese Abhängigkeiten sind nicht mehr erforderlich. Der IronOCR PDF-Eingabeleitfaden umfasst alle PDF-Eingabevarianten, die von diesen Bibliotheken unterstützt werden, einschließlich Seitenbereichsauswahl und passwortgeschützter Dokumente. Der gesamte Render-dann-OCR-Block — normalerweise 50-80 Zeilen, verteilt auf drei Bibliotheken — reduziert sich auf input.LoadPdf(path) gefolgt von einem einzigen Read() Aufruf.

Ersetzung des Vorverarbeitungscodes

Die bestehenden Vorverarbeitungsmethoden — ConvertToGrayscale, EnhanceContrast, Binarize, RemoveNoise, Deskew, ScaleToDpi — sind direkt auf IronOCR-Filtermethoden abbildbar. Das Muster des Speicherns und Ladens temporärer Dateien verschwindet vollständig. Beachten Sie die Anleitung zur Bildfarbkorrektur für farbspezifische Transformationen und die Anleitung zu den DPI-Einstellungen für die Auflösungsverwaltung.

Gewindemodelländerung

Code, der TesseractEngine innerhalb einer Parallel.ForEach Schleife erstellt — jeweils eins pro Thread — ändert sich zu der Erstellung von IronTesseract einmal vor der Schleife und der Teilung über alle Threads. Dies ist eine Korrektur der Korrektheit, nicht nur eine Umstrukturierung: Das alte Muster war defensive Programmierung um eine threadsichere API herum; Das neue Muster ist die beabsichtigte Verwendung einer threadsicheren API. Der pro Thread auftretende Initialisierungsaufwand der Engine – 40-100 MB an Sprachmodelldaten pro Thread – entfällt durch die Änderung, da IronOCR einen gemeinsamen internen Pool verwaltet, anstatt den gesamten Modellzustand pro Engine-Instanz zu laden.