Ein Vergleich zwischen Google OCR & IronOCR

NativeBinärbereitstellung

Das native Binärverwaltungsmuster incharlesw/tesseractstellt das größte praktische Problem für Teams dar, die von einer lokalen Entwicklungsmaschine wegkommen wollen:

// charlesw/Tesseract: engine creation requires tessdata path at runtime
// The path must resolve correctly in every deployment target

private const string TessDataPath = @"./tessdata"; // Works on dev — breaks in Docker

public string ExtractText(string imagePath)
{
    // TesseractEngine P/Invokes into platform-specific native DLLs
    // Fails with DllNotFoundException if binaries are not in the right location
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);

    return page.GetText();
}

// charlesw/Tesseract: engine creation requires tessdata path at runtime
// The path must resolve correctly in every deployment target

private const string TessDataPath = @"./tessdata"; // Works on dev — breaks in Docker

public string ExtractText(string imagePath)
{
    // TesseractEngine P/Invokes into platform-specific native DLLs
    // Fails with DllNotFoundException if binaries are not in the right location
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);

    return page.GetText();
}

Imports Tesseract

Private Const TessDataPath As String = "./tessdata" ' Works on dev — breaks in Docker

Public Function ExtractText(imagePath As String) As String
    ' TesseractEngine P/Invokes into platform-specific native DLLs
    ' Fails with DllNotFoundException if binaries are not in the right location
    Using engine As New TesseractEngine(TessDataPath, "eng", 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

Der TessDataPath String muss sich auf jedem Bereitstellungsziel unterschiedlich auflösen. Auf einem Entwickler-Windows-Rechner verweist es auf einen lokalen Ordner. In einem Docker-Linux-Container existiert dieser Ordner nicht, es sei denn, das Image-Build COPYs tessdata explizit ein. Bei Azure App Service unterscheidet sich der Anwendungsstammpfad von einem lokalen Pfad. Jede Umgebung erfordert bedingte Pfadlogik oder explizite Bereitstellungsskripte, und keine dieser Logiken befindet sich im Paket – es handelt sich ausschließlich um aufrufenden Code, der geschrieben und gewartet werden muss.

Die nativen Binärdateien selbst erfordern die gleiche Aufmerksamkeit. Bei Veröffentlichungsprofilen, die auf eigenständige .NET 8-Bereitstellungen abzielen, muss die Laufzeitkennung mit der Binärvariante übereinstimmen, die das Paket ausliefert. Eine win-x64 Veröffentlichung umfasst die x64 native DLL; Eine linux-arm64 Bereitstellung erfordert die Verifizierung, dass das Paket eine ARM64-Binärdatei liefert - und für ein archiviertes Paket können Teams keinen Fehler melden, um es anzufordern, wenn die Binärdatei fehlt.

Detaillierter Funktionsvergleich

charlesw/tesseract: Was archiviert in der Praxis bedeutet

Wenn ein GitHub Repository archiviert wird, hat der Verantwortliche bewusst entschieden, die Entwicklung einzustellen. Das Repositorycharlesw/tesseractzeigt diesen Status deutlich an. Seit 2021 wurden keine Änderungen mehr vorgenommen. Die Tesseract 5-Engine, die im Dezember 2021 mit einem neu geschriebenen LSTM-Modell veröffentlicht wurde, das eine höhere Genauigkeit bei Scans mit geringer Qualität bietet, ist in diesem Paket nicht enthalten. Alle seit der Archivierung entdeckten Fehler – einschließlich Kompatibilitätsprobleme mit neueren .NET Laufzeitumgebungen, geändertes natives Binärladeverhalten unter Linux oder sicherheitsrelevante Probleme in der Tesseract C-Bibliothek – lassen sich nicht beheben.

Neue Projekte, die heute eine NuGet-Abhängigkeit von Tesseract aufnehmen, beginnen mit einem Paket, das bereits seine letzte Aktualisierung erhalten hat. In zwölf Monaten wird diese Abhängigkeit ein Jahr weiter von jeglicher Wartung entfernt sein. In drei Jahren wird es wahrscheinlich auf den dann aktuellen .NET -Laufzeitumgebungen nicht mehr funktionieren. Das Paket wird weiterhin installiert und die Basis-API wird weiterhin kompiliert, aber der Wartungsaufwand häuft sich unsichtbar an.

Die praktische Konsequenz jenseits der Genauigkeitslücke: Wenn eine kritische CVE für den C++-Code von Tesseract 4.1.1 veröffentlicht wird, erhält das NuGet Paket charlesw keinen Patch. Die einzigen Alternativen sind das Forken und Neuerstellen nativer Binärdateien aus dem Quellcode – ein nicht triviales Unterfangen – oder das Akzeptieren der Offenlegung.

IronOCR-Ansatz

IronOCR liefert Tesseract 5 mit Verbesserungen an der Erkennungspipeline aus, und die Bibliothek erhält regelmäßige Updates. Die Genauigkeitsverbesserungen gegenüber dem Tesseract 5-Modell sind ohne Codeänderungen verfügbar – sie werden durch ein Paketupdate bereitgestellt. Die IronTesseract-Einrichtungsanleitung beschreibt die aktuelle API, die die aktive Entwicklung widerspiegelt und nicht einen eingefrorenen Stand aus dem Jahr 2021.

Für die produktive OCR in einer .NET -Anwendung stellt die Abhängigkeit von einer archivierten Bibliothek ein Geschäftsrisiko dar und ist nicht nur eine Frage der technischen Präferenz. Ziel dieses Vergleichs ist es, dieses Risiko ehrlich einzuschätzen.

charlesw/tesseract-Ansatz

Das Tesseract NuGet-Paket enthält native Binärdateien für die gängigsten Plattformen in seinem runtimes/ Ordner. Auf einer Entwickler-Workstation, die das standardmäßige Veröffentlichungsverhalten des .NET SDK verwendet, werden diese Binärdateien automatisch in das Ausgabeverzeichnis kopiert und alles funktioniert. Die Probleme treten auf, wenn die Bereitstellungsziele von diesem Idealfall abweichen:

// Production code must handle path differences across environments
// There is no standard solution — every team builds their own

public class TesseractEngineFactory
{
    private static string ResolveTessDataPath()
    {
        // Dev machine: ./tessdata relative to executable
        // Docker: /app/tessdata (must be COPY'd into image)
        // Azure App Service: D:\home\site\wwwroot\tessdata
        // All three paths are different; all three need correct traineddata files

        var candidates = new[]
        {
            Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tessdata"),
            Path.Combine(Directory.GetCurrentDirectory(), "tessdata"),
            "/app/tessdata",  // Docker-specific hard-code
        };

        foreach (var candidate in candidates)
        {
            if (Directory.Exists(candidate))
                return candidate;
        }

        throw new DirectoryNotFoundException("tessdata not found — deployment misconfigured");
    }

    public static TesseractEngine Create()
    {
        // TesseractEngine P/Invokes tesseract50.dll on Windows, libtesseract.so on Linux
        // If the native binary for the current runtime identifier is missing, throws DllNotFoundException
        return new TesseractEngine(ResolveTessDataPath(), "eng", EngineMode.Default);
    }
}

// Production code must handle path differences across environments
// There is no standard solution — every team builds their own

public class TesseractEngineFactory
{
    private static string ResolveTessDataPath()
    {
        // Dev machine: ./tessdata relative to executable
        // Docker: /app/tessdata (must be COPY'd into image)
        // Azure App Service: D:\home\site\wwwroot\tessdata
        // All three paths are different; all three need correct traineddata files

        var candidates = new[]
        {
            Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tessdata"),
            Path.Combine(Directory.GetCurrentDirectory(), "tessdata"),
            "/app/tessdata",  // Docker-specific hard-code
        };

        foreach (var candidate in candidates)
        {
            if (Directory.Exists(candidate))
                return candidate;
        }

        throw new DirectoryNotFoundException("tessdata not found — deployment misconfigured");
    }

    public static TesseractEngine Create()
    {
        // TesseractEngine P/Invokes tesseract50.dll on Windows, libtesseract.so on Linux
        // If the native binary for the current runtime identifier is missing, throws DllNotFoundException
        return new TesseractEngine(ResolveTessDataPath(), "eng", EngineMode.Default);
    }
}

Imports System
Imports System.IO

' Production code must handle path differences across environments
' There is no standard solution — every team builds their own

Public Class TesseractEngineFactory
    Private Shared Function ResolveTessDataPath() As String
        ' Dev machine: ./tessdata relative to executable
        ' Docker: /app/tessdata (must be COPY'd into image)
        ' Azure App Service: D:\home\site\wwwroot\tessdata
        ' All three paths are different; all three need correct traineddata files

        Dim candidates = New String() {
            Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tessdata"),
            Path.Combine(Directory.GetCurrentDirectory(), "tessdata"),
            "/app/tessdata"  ' Docker-specific hard-code
        }

        For Each candidate In candidates
            If Directory.Exists(candidate) Then
                Return candidate
            End If
        Next

        Throw New DirectoryNotFoundException("tessdata not found — deployment misconfigured")
    End Function

    Public Shared Function Create() As TesseractEngine
        ' TesseractEngine P/Invokes tesseract50.dll on Windows, libtesseract.so on Linux
        ' If the native binary for the current runtime identifier is missing, throws DllNotFoundException
        Return New TesseractEngine(ResolveTessDataPath(), "eng", EngineMode.Default)
    End Function
End Class

Die tessdata-Dateien selbst fügen einen weiteren Bereitstellungsschritt hinzu. Für Englisch beträgt eng.traineddata etwa 15 MB. Für jede zusätzliche Sprache muss eine weitere 15 MB-Datei vom Tesseract GitHub-Repository heruntergeladen, in die Versionskontrolle oder einen Bereitstellungs-Artefaktspeicher aufgenommen, konfiguriert werden, um ins Ausgabeverzeichnis im .csproj kopiert zu werden, und in jeder Umgebung vorhanden sein. Der .csproj Eintrag sieht aus wie:

<ItemGroup>
  <None Update="tessdata\**\*">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </None>
</ItemGroup>

<ItemGroup>
  <None Update="tessdata\**\*">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </None>
</ItemGroup>

Vergessen Sie diesen Eintrag in einem neuen Projekt, stellen Sie es auf CI bereit, und die OCR-Pipeline schlägt zur Laufzeit mit einem Pfadfehler fehl – ​​nicht mit einem Kompilierungsfehler. Die Fehler treten in der Produktion oder in der Vorbereitungsphase auf, nicht während der Montage.

Auf ARM64 Linux – was zunehmend relevant wird, da AWS Graviton und Apple Silicon Build-Agents zum Standard werden – bietet das archivierte Paket keine Garantie für aktualisierte Binärdateien. Die letzte Veröffentlichung des Pakets erfolgte vor der weitverbreiteten Einführung der ARM64-Serverinfrastruktur.

IronOCR-Ansatz

IronOCR bündelt alle nativen Binärdateien und die englischen Tessdata-Dateien im NuGet -Paket selbst. Es gibt keine tessdata-Dateien zu verwalten, keine .csproj CopyToOutputDirectory Einträge und keine plattformspezifische Pfadlogik zum Schreiben. Die gesamte Installation ist:

// Install: dotnet add package IronOcr
//Neintessdata download.Neinnative binary configuration.Neinpath management.

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

var text = new IronTesseract().Read("document.jpg").Text;

// Install: dotnet add package IronOcr
//Neintessdata download.Neinnative binary configuration.Neinpath management.

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

var text = new IronTesseract().Read("document.jpg").Text;

' Install: dotnet add package IronOcr
'Neintessdata download.Neinnative binary configuration.Neinpath management.

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

Dim text As String = New IronTesseract().Read("document.jpg").Text

Dieser Code läuft unverändert unter Windows x64, Linux x64, Linux ARM64, macOS x64 und macOS ARM64. Dieselbe Binärdatei lässt sich ohne plattformspezifische Logik in Docker, Azure App Service und AWS Lambda bereitstellen. Die Docker-Bereitstellungsanleitung und die Linux-Bereitstellungsanleitung dokumentieren die spezifischen Anforderungen für Nicht-Windows-Ziele, die minimal sind.

Zusätzliche Sprachen werden über NuGet installiert – keine Dateidownloads, keine Verzeichniskonfiguration:

// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.German

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);
var result = ocr.Read("multilingual-document.jpg");

// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.German

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);
var result = ocr.Read("multilingual-document.jpg");

Imports IronOcr

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.French
ocr.AddSecondaryLanguage(OcrLanguage.German)
Dim result = ocr.Read("multilingual-document.jpg")

Der Unterschied im Aufwand für die Bereitstellung ist nicht geringfügig. Teams, diecharlesw/tesseractin CI/CD-Pipelines mit mehreren Bereitstellungszielen pflegen, verbringen regelmäßig 4–8 Stunden mit der Fehlersuche in Pfad- und Binärdateien, die IronOCR vollständig beseitigt. Eine vollständige Anleitung zum Lesen von Text aus Bildern ohne Implementierungsprobleme bietet das IronOCR Tutorial, das das gesamte Muster abdeckt.

charlesw/tesseract-Ansatz

Bei sauberen Scans mit hoher DPI-Auflösung liefert Tesseract 4.1.1 vergleichbare Ergebnisse wie Tesseract 5. Die Unterschiede zeigen sich bei schlechteren Eingaben: niedrig aufgelöste Bilder, leicht verzerrte Dokumente, Faxe und Fotografien von gedrucktem Text. Das LSTM-Modell von Tesseract 4.1.1 profitierte nicht von den zusätzlichen Trainingsdaten und den Architekturverbesserungen, die in Tesseract 5 enthalten waren.

Noch kritischer ist, dasscharlesw/tesseractkeine Vorverarbeitung durchführt. Ein Rohbild wird direkt an die Engine gesendet. Bei einem Scan mit 150 dpi von einem handelsüblichen Flachbettscanner sinkt die Genauigkeit auf 40–70 %. Bei einem um 5 Grad geneigten Dokument kann die Genauigkeit unter 70 % fallen. Bei einem Foto eines Dokuments, das unter einem leichten Winkel und bei ungleichmäßiger Beleuchtung aufgenommen wurde, kann die Genauigkeit 10–40 % betragen:

// charlesw/Tesseract: what you get without preprocessing
public string ExtractText(string imagePath)
{
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);

    // On a poor-quality scan: 40-70% accuracy
    // On a skewed document: 60-80% accuracy
    // On a photo of a document: 10-40% accuracy
    return page.GetText();
}

// charlesw/Tesseract: what you get without preprocessing
public string ExtractText(string imagePath)
{
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);

    // On a poor-quality scan: 40-70% accuracy
    // On a skewed document: 60-80% accuracy
    // On a photo of a document: 10-40% accuracy
    return page.GetText();
}

Imports Tesseract

Public Function ExtractText(imagePath As String) As String
    Using engine As New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
        Using img As Pix = Pix.LoadFromFile(imagePath)
            Using page As Page = engine.Process(img)
                ' On a poor-quality scan: 40-70% accuracy
                ' On a skewed document: 60-80% accuracy
                ' On a photo of a document: 10-40% accuracy
                Return page.GetText()
            End Using
        End Using
    End Using
End Function

Um eine brauchbare Genauigkeit zu erreichen, ist eine Vorverarbeitungskette erforderlich – Graustufenkonvertierung, Kontrastverstärkung, Binarisierung, Entzerrung mittels Hough-Transformation oder Projektionsprofilen, Rauschentfernung und DPI-Normalisierung. Diese Pipeline besteht aus 100–300 Zeilen zusätzlichem Code unter Verwendung von System.Drawing, SixLabors.ImageSharp oder ähnlichem - keiner davon ist Teil des Tesseract-Pakets. Jeder Vorverarbeitungsschritt erfordert eine separate Implementierung, Tests und Optimierung. Allein der Schritt der Entzerrung, korrekt implementiert mit einer Hough-Transformation, umfasst mehr als 50 Zeilen.

IronOCR-Ansatz

IronOCR führt eine automatische Vorverarbeitung durch, bevor das Bild an die Tesseract 5-Engine übergeben wird. Derselbe Scan mit geringer Qualität, der mitcharlesw/tesseracteine Genauigkeit von 40–70 % liefert, erzielt mit IronOCR eine Genauigkeit von über 95 %, da die Bibliothek das Bild normalisiert, bevor die Engine es verarbeitet. Wenn eine explizite Steuerung erforderlich ist, spiegelt die Vorverarbeitungs-API die Pipeline-Schritte wider, ohne dass eine benutzerdefinierte Implementierung erforderlich ist:

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

// Named preprocessing steps — no custom image processing code
input.Deskew();               // Corrects rotation up to ~10 degrees
input.DeNoise();              // Removes speckle and scanner noise
input.Contrast();             // Normalizes contrast
input.Binarize();             // Adaptive thresholding
input.EnhanceResolution(300); // Upsamples to 300 DPI if needed

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

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

// Named preprocessing steps — no custom image processing code
input.Deskew();               // Corrects rotation up to ~10 degrees
input.DeNoise();              // Removes speckle and scanner noise
input.Contrast();             // Normalizes contrast
input.Binarize();             // Adaptive thresholding
input.EnhanceResolution(300); // Upsamples to 300 DPI if needed

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

Imports IronOcr

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

    ' Named preprocessing steps — no custom image processing code
    input.Deskew()               ' Corrects rotation up to ~10 degrees
    input.DeNoise()              ' Removes speckle and scanner noise
    input.Contrast()             ' Normalizes contrast
    input.Binarize()             ' Adaptive thresholding
    input.EnhanceResolution(300) ' Upsamples to 300 DPI if needed

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

Der Leitfaden zur Bildqualitätskorrektur dokumentiert den vollständigen Satz der Vorverarbeitungsfilter und deren Anwendungsfälle. Für Dokumente mit farbigem Hintergrund oder ungleichmäßiger Ausleuchtung werden im Leitfaden zur Bildfarbkorrektur zusätzliche Filter beschrieben. Beide Anleitungen spiegeln die aktuelle API wider – im Gegensatz zur Dokumentation von charlesw, die eine Bibliothek beschreibt, die keine Updates mehr erhält.

Speziell für Szenarien mit geringer Scanqualität zeigt das Beispiel der OCR-Verarbeitung bei geringer Scanqualität den Unterschied in der Genauigkeit vor und nach der Bearbeitung anhand konkreter Eingaben.

charlesw/tesseract-Ansatz

Teams, diecharlesw/tesseractin mehreren Umgebungen einsetzen, sammeln bedingte Bereitstellungslogik an, die nichts mit OCR zu tun hat. Der Pfad zu tessdata variiert je nach Umgebung. Das Verhalten beim Laden nativer Binärdateien unterscheidet sich zwischen Windows und Linux. Docker-Images erfordern explizite COPY Anweisungen und apt-get Befehle für Leptonica-Abhängigkeiten auf einigen Linux-Basis-Images:

// Platform-conditional code required to deploy charlesw/Tesseract
// This block exists in real production codebases

public static class TesseractFactory
{
    public static string GetTessDataPath()
    {
        // Runtime environment detection — purely deployment plumbing
        if (Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER") == "true")
        {
            // Docker: tessdata must be explicitly COPY'd into the image
            return "/app/tessdata";
        }

        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            // Linux bare metal: path convention differs from Windows
            return Path.Combine(AppContext.BaseDirectory, "tessdata");
        }

        // Windows dev machine
        return @"./tessdata";
    }

    public static TesseractEngine CreateEngine()
    {
        // x86/x64 conditional logic may be needed for specific deployment targets
        // EngineMode.Default uses LSTM; EngineMode.TesseractOnly uses legacy engine
        return new TesseractEngine(GetTessDataPath(), "eng", EngineMode.Default);
    }
}

// Platform-conditional code required to deploy charlesw/Tesseract
// This block exists in real production codebases

public static class TesseractFactory
{
    public static string GetTessDataPath()
    {
        // Runtime environment detection — purely deployment plumbing
        if (Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER") == "true")
        {
            // Docker: tessdata must be explicitly COPY'd into the image
            return "/app/tessdata";
        }

        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            // Linux bare metal: path convention differs from Windows
            return Path.Combine(AppContext.BaseDirectory, "tessdata");
        }

        // Windows dev machine
        return @"./tessdata";
    }

    public static TesseractEngine CreateEngine()
    {
        // x86/x64 conditional logic may be needed for specific deployment targets
        // EngineMode.Default uses LSTM; EngineMode.TesseractOnly uses legacy engine
        return new TesseractEngine(GetTessDataPath(), "eng", EngineMode.Default);
    }
}

Imports System
Imports System.IO
Imports System.Runtime.InteropServices

Public Module TesseractFactory
    Public Function GetTessDataPath() As String
        ' Runtime environment detection — purely deployment plumbing
        If Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER") = "true" Then
            ' Docker: tessdata must be explicitly COPY'd into the image
            Return "/app/tessdata"
        End If

        If RuntimeInformation.IsOSPlatform(OSPlatform.Linux) Then
            ' Linux bare metal: path convention differs from Windows
            Return Path.Combine(AppContext.BaseDirectory, "tessdata")
        End If

        ' Windows dev machine
        Return "./tessdata"
    End Function

    Public Function CreateEngine() As TesseractEngine
        ' x86/x64 conditional logic may be needed for specific deployment targets
        ' EngineMode.Default uses LSTM; EngineMode.TesseractOnly uses legacy engine
        Return New TesseractEngine(GetTessDataPath(), "eng", EngineMode.Default)
    End Function
End Module

Die Dockerfile für ein Projekt, dascharlesw/tesseractverwendet, erfordert das explizite Kopieren von tessdata und möglicherweise die Installation des Leptonica-Pakets auf Systemebene, abhängig vom Basis-Image:

# Dockerfile for charlesw/Tesseract deployment
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base

# Leptonica may need system installation depending on base image
RUN apt-get update && apt-get install -y libleptonica-dev

COPY --from=build /app/publish /app

# tessdata must be explicitly staged — not bundled in the NuGet package
COPY tessdata/ /app/tessdata/

WORKDIR /app
ENTRYPOINT ["dotnet", "YourApp.dll"]

Diese Dockerfile bettet operatives Wissen über das Bereitstellungsmodell voncharlesw/tesseractdirekt in den Infrastrukturcode ein. Wenn sich das Basis-Image ändert oder die Linux-Distribution Leptonica aktualisiert, schlägt der Build fehl. Bei einem archivierten Paket besteht die einzige Abhilfemaßnahme in der Pflege einer benutzerdefinierten nativen Binär-Build-Pipeline.

IronOCR-Ansatz

IronOCR verfügt über keinen tessdata COPY-Schritt, keine Systempaketinstallation für Leptonica und keine plattformabhängige Pfadlogik. Der Docker-Bereitstellungsleitfaden für IronOCR erfordert nur die Standard libgdiplus Installation für System.Drawing Unterstützung auf Linux - Infrastruktur, die jede .NET-Anwendung auf Linux bereits benötigt:

# Dockerfile for IronOCR deployment
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base

# libgdiplus is standard for any .NET app using System.Drawing on Linux
RUN apt-get update && apt-get install -y libgdiplus

COPY --from=build /app/publish /app

#Neintessdata COPY.NeinLeptonica apt-get.Neinnative binary management.

WORKDIR /app
ENTRYPOINT ["dotnet", "YourApp.dll"]

Der AWS-Bereitstellungsleitfaden und der Azure-Bereitstellungsleitfaden folgen dem gleichen Muster: ein Standard-Systempaket, dann die Anwendung. Es ist kein bibliotheksspezifischer Infrastrukturcode erforderlich.

Greenfield-Projekte, die ein altes Tutorial wiedergefunden haben

Das häufigste Szenario ist ein Entwickler, der ein neues Projekt startet, eine Stack Overflow-Antwort oder einen Blogartikel aus 2019 oder 2020 findet, der charlesw/tesseract erwähnt, das Paket installiert und in der Mitte des Projekts feststellt, dass es archiviert ist. An diesem Punkt steht das Team vor einer Entscheidung: Entweder es bleibt bei der eingefrorenen Abhängigkeit oder es migriert, bevor die Codebasis wächst. Teams, die den archivierten Status vor der Auslieferung erkennen, migrieren in der Regel sofort – die API-Oberfläche ist klein genug, dass die Migration voncharlesw/tesseractzu IronOCR typischerweise nur wenige Stunden dauert und das Risiko laufender Wartungsarbeiten entfällt. Das IronOCR Tutorial-Portal bietet aktuelle Beispiele, die die veralteten Community-Inhalte ersetzen, welche überhaupt erst zu der Abhängigkeit voncharlesw/tesseractgeführt haben.

Anforderungen an die plattformübergreifende Bereitstellung

Teams, diecharlesw/tesseractzunächst unter Windows einsetzten und dann Linux-Ziele hinzufügten – was mit zunehmender Verbreitung von Kubernetes und Docker üblich war –, stießen in vollem Umfang auf die Komplexität der nativen Binärbereitstellung. Konfiguration von Tessdata-Pfaden, Überprüfung der Leptonica-Verfügbarkeit, Verwaltung plattformabhängiger Docker-Anweisungen: Das summiert sich schnell. Wenn das Bereitstellungsziel ARM64 hinzufügt (AWS Graviton aus Kostengründen, Apple Silicon für CI), wird die Binärunterstützung des archivierten Pakets ungewiss. Teams in dieser Situation evaluieren IronOCR, wenn der Aufwand für die Bereitstellungsunterstützung die Kosten der kommerziellen Lizenz übersteigt. Der Linux-Bereitstellungsleitfaden zeigt, wie die IronOCR Bereitstellung im Vergleich dazu aussieht: wesentlich einfacher. Siehe die Lizenzierungsseite für aktuelle Preisinformationen.

Dokumente, die die Genauigkeitsschwellenwerte nicht erreichen

Teams, diecharlesw/tesseractauf sauberen, kontrollierten Eingabedaten – hochauflösenden Scans von getippten Dokumenten – verwenden, erzielen zufriedenstellende Ergebnisse und haben keinen unmittelbaren Grund, zu wechseln. Auslöser ist der Eingang realer Dokumente: gescannte Formulare von externen Stellen, Faxe, Fotos von Mobilgeräten, ältere Drucksachen mit vermindertem Kontrast. Ohne Vorverarbeitung sinkt die Genauigkeit von CharlesW/Tesseract bei diesen Eingaben unter ein brauchbares Niveau. Der Aufbau einer Vorverarbeitungspipeline auf Basis eines archivierten Pakets bedeutet, Entwicklungszeit in eine Infrastruktur zu investieren, die eine Abhängigkeit ohne Zukunft unterstützt. An diesem Wendepunkt wird die Argumentation für die automatische Vorverarbeitung von IronOCR und die Genauigkeit von Tesseract 5 eindeutig.

Sicherheits- und Compliance-Überprüfungen

Abhängigkeitsprüfungen in regulierten Bereichen – Gesundheitswesen, Finanzen, Regierung – kennzeichnen archivierte Datenpakete als Auffälligkeiten. Eine Abhängigkeit, die keine Sicherheitspatches erhalten kann, stellt unabhängig von ihrem aktuellen Schwachstellenstatus ein Compliance-Risiko dar. Das Paketcharlesw/tesseractkapselt eine C++-Bibliothek; Für zukünftige CVEs im C-Code von Tesseract 4.1.1 gibt es keine Möglichkeit zur Behebung über das NuGet Paket. Die Compliance-Teams, die ein System überprüfen, das auf einer archivierten Abhängigkeit basiert, benötigen entweder einen Ersatz oder eine dokumentierte Ausnahme. Teams, die bei einem Sicherheitsaudit auf dieses Problem stoßen, wählen IronOCR, um den Befund zu beheben, anstatt für jeden Auditzyklus eine Ausnahme zu dokumentieren.

Tesseract 5 Genauigkeitsanforderung

Teams, diecharlesw/tesseractanhand von Genauigkeitsanforderungen getestet und festgestellt haben, dass Tesseract 4.1.1 unzureichend ist – insbesondere bei handgeschriebenem Text, fehlerhaften Scans oder Dokumenten mit ungewöhnlichen Schriftarten – können die Engine nicht über das archivierte Paket aktualisieren. Tesseract 5 ist ohne einen Bibliothekswechsel nicht verfügbar.IronOCR bietet die Genauigkeit von Tesseract 5 und zusätzlich eine automatische Vorverarbeitung, die die Genauigkeitsverbesserung noch verstärkt. Der Unterschied bei den beeinträchtigten Dokumenten ist so groß (40–70 % gegenüber über 95 % bei Scans mit niedriger DPI-Auflösung), dass er Migrationsentscheidungen unabhängig von Wartungsaspekten beeinflusst.

Ersetzen von TesseractEngine durch IronTesseract

Diecharlesw/tesseractAPI konzentriert sich darauf, einen TesseractEngine mit einem expliziten tessdata-Pfad und einem Sprachcodestring zu erstellen.IronOCR ersetzt dieses gesamte Konstruktionsmuster durch einen parameterlosen Konstruktor. Die Motoreinstellungen, die implizit in der TessDataPath Konstanten und EngineMode Enum waren, werden irrelevant -IronOCR verwaltet seine eigene Motorinitialisierung intern:

// Before: charlesw/Tesseract
using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);
using var img = Pix.LoadFromFile(imagePath);
using var page = engine.Process(img);
var text = page.GetText();

// After: IronOCR
var text = new IronTesseract().Read(imagePath).Text;

// Before: charlesw/Tesseract
using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);
using var img = Pix.LoadFromFile(imagePath);
using var page = engine.Process(img);
var text = page.GetText();

// After: IronOCR
var text = new IronTesseract().Read(imagePath).Text;

Imports Tesseract

Dim text As String

Using engine As New TesseractEngine("./tessdata", "eng", EngineMode.Default)
    Using img As Pix = Pix.LoadFromFile(imagePath)
        Using page As Page = engine.Process(img)
            text = page.GetText()
        End Using
    End Using
End Using

' After: IronOCR
text = New IronTesseract().Read(imagePath).Text

Die TessDataPath Konstante, der tessdata-Ordner und der .csproj CopyToOutputDirectory Eintrag werden alle gelöscht. Jeglicher plattformabhängiger Pfadauflösungscode löscht ebenfalls. Die IronTesseract-API-Referenz deckt die gesamte Konfigurationsoberfläche ab, falls über die Standardeinstellungen hinausgehende Anpassungen auf Engine-Ebene erforderlich sind.

Ersetzen des Seiteniterators durch strukturierte Ergebnisse

charlesw/tesseract stellt Wort-Daten durch ein Iterator-Muster bereit - page.GetIterator(), iter.Begin(), iter.Next() mit PageIteratorLevel Enum-Werten.IronOCR ersetzt dies durch direkten Zugriff auf die Sammlung des Ergebnisobjekts. Der Iterator-Standardcode wird gelöscht; Die Daten sind direkt zugänglich:

// Before: charlesw/Tesseract iterator pattern
using var iter = page.GetIterator();
iter.Begin();
do
{
    if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
    {
        var word = iter.GetText(PageIteratorLevel.Word);
        var confidence = iter.GetConfidence(PageIteratorLevel.Word);
        Console.WriteLine($"'{word?.Trim()}' at ({bounds.X1},{bounds.Y1}) - {confidence:P1}");
    }
} while (iter.Next(PageIteratorLevel.Word));

// After:IronOCR direct collection access
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) - {word.Confidence}%");
}

// Before: charlesw/Tesseract iterator pattern
using var iter = page.GetIterator();
iter.Begin();
do
{
    if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
    {
        var word = iter.GetText(PageIteratorLevel.Word);
        var confidence = iter.GetConfidence(PageIteratorLevel.Word);
        Console.WriteLine($"'{word?.Trim()}' at ({bounds.X1},{bounds.Y1}) - {confidence:P1}");
    }
} while (iter.Next(PageIteratorLevel.Word));

// After:IronOCR direct collection access
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) - {word.Confidence}%");
}

Imports System

' Before: charlesw/Tesseract iterator pattern
Using iter = page.GetIterator()
    iter.Begin()
    Do
        Dim bounds As Object
        If iter.TryGetBoundingBox(PageIteratorLevel.Word, bounds) Then
            Dim word = iter.GetText(PageIteratorLevel.Word)
            Dim confidence = iter.GetConfidence(PageIteratorLevel.Word)
            Console.WriteLine($"'{word?.Trim()}' at ({bounds.X1},{bounds.Y1}) - {confidence:P1}")
        End If
    Loop While iter.Next(PageIteratorLevel.Word)
End Using

' After: IronOCR direct collection access
Dim result = New IronTesseract().Read(imagePath)
For Each word In result.Words
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) - {word.Confidence}%")
Next

Der Leitfaden zu den Leseergebnissen umfasst das gesamte strukturierte Ergebnismodell – Seiten, Absätze, Zeilen, Wörter und Zeichen –, das ohne Iteratorverwaltung zugänglich ist.

PDF-Unterstützung hinzufügen

charlesw/tesseract verfügt über keine PDF-Funktion. Projekte, die PDFs neben Bildern verarbeiten, haben typischerweise eine zweite Abhängigkeit - PdfiumViewer, PDFtoImage, oder ähnliches - das PDF-Seiten in Bitmap Objekte rendert, bevor sie Tesseract übergeben werden. Diese sekundäre Bibliothek und ihre eigene native Binärabhängigkeit können bei der Migration zu IronOCR vollständig entfernt werden:

// Before: charlesw/Tesseract + PdfiumViewer (two libraries, two native dependencies)
using (var document = PdfDocument.Load(pdfPath))
using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
{
    for (int i = 0; i < document.PageCount; i++)
    {
        using var pageImage = document.Render(i, 300, 300, PdfRenderFlags.CorrectFromDpi);
        // Save temp file, load into Pix, process, delete temp file...
    }
}

// After:IronOCR(one library, native PDF support)
var text = new IronTesseract().Read(pdfPath).Text;

// Before: charlesw/Tesseract + PdfiumViewer (two libraries, two native dependencies)
using (var document = PdfDocument.Load(pdfPath))
using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
{
    for (int i = 0; i < document.PageCount; i++)
    {
        using var pageImage = document.Render(i, 300, 300, PdfRenderFlags.CorrectFromDpi);
        // Save temp file, load into Pix, process, delete temp file...
    }
}

// After:IronOCR(one library, native PDF support)
var text = new IronTesseract().Read(pdfPath).Text;

Imports PdfiumViewer
Imports Tesseract

Using document As PdfDocument = PdfDocument.Load(pdfPath)
    Using engine As New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
        For i As Integer = 0 To document.PageCount - 1
            Using pageImage = document.Render(i, 300, 300, PdfRenderFlags.CorrectFromDpi)
                ' Save temp file, load into Pix, process, delete temp file...
            End Using
        Next
    End Using
End Using

' After:IronOCR(one library, native PDF support)
Dim text As String = New IronTesseract().Read(pdfPath).Text

Der Leitfaden zur PDF-Eingabe behandelt die Auswahl von Seitenbereichen, passwortgeschützte PDFs und die Ausgabe durchsuchbarer PDFs – Funktionen, die untercharlesw/tesseractseparate Bibliotheken und erheblichen Code erforderten.

Sprachpaketmigration

Jede Sprache incharlesw/tesseracterforderte einen separaten .traineddata Datei-Download, manuelle Speicherung und explizite Bereitstellungskonfiguration. Die Migration zu IronOCR-Sprachpaketen ist eine NuGet Paketerweiterung pro Sprache, ohne weitere Änderungen:

# Remove manual tessdata files and .csproj CopyToOutputDirectory entries
# Add NuGet Sprachpakete instead:
dotnet add package IronOcr.Languages.French
dotnet add package IronOcr.Languages.German

# Remove manual tessdata files and .csproj CopyToOutputDirectory entries
# Add NuGet Sprachpakete instead:
dotnet add package IronOcr.Languages.French
dotnet add package IronOcr.Languages.German

Der Leitfaden für mehrere Sprachen behandelt die gleichzeitige mehrsprachige Erkennung. Der Sprachindex listet alle über 125 verfügbaren Sprachpakete auf.