Porównanie pomiędzy Google OCR a IronOCR

Wdrażanie natywnych plików binarnych

Natywny wzorzec zarządzania plikami binarnymi wcharlesw/tesseractstanowi główny praktyczny problem dla zespołów wychodzących poza lokalną maszynę programistyczną:

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

Ciąg TessDataPath musi być rozwiązywany inaczej na każdym celu wdrożenia. Na komputerze programisty z systemem Windows wskazuje on folder lokalny. W kontenerze Linux Docker ten folder nie istnieje, chyba że budowa obrazu jawnie COPY tessdata do wewnątrz. W usłudze Azure App Service ścieżka katalogu głównego aplikacji różni się od ścieżki lokalnej. Każde środowisko wymaga logiki ścieżek warunkowych lub jawnych skryptów wdrożeniowych, a żadna z tych logik nie znajduje się w pakiecie — jest to w całości kod, który musi napisać i utrzymywać wywołujący.

Te same wymagania dotyczą również samych plików binarnych. W profilach publikacji przeznaczonych dla samodzielnych wdrożeń .NET 8 identyfikator środowiska uruchomieniowego musi odpowiadać wariantowi pliku binarnego dostarczanego w pakiecie. Publikacja win-x64 zawiera natywny plik DLL x64; Wdrożenie linux-arm64 wymaga weryfikacji, że pakiet dostarcza binarium ARM64 — a dla zarchiwizowanego pakietu zespoły nie mogą zgłosić problemu, aby go zażądać, jeśli binarium jest nieobecne.

Szczegółowe porównanie funkcji

charlesw/tesseract: Co oznacza zarchiwizowanie w praktyce

Archiwizacja repozytorium GitHub oznacza, że opiekun podjął świadomą decyzję o zaprzestaniu wszelkich prac rozwojowych. Repozytoriumcharlesw/tesseractwyraźnie pokazuje ten status. Od 2021 r. nie wprowadzono żadnych zmian. Silnik Tesseract 5, który został wydany w grudniu 2021 r. z przeprogramowanym modelem LSTM zapewniającym wyższą dokładność w przypadku skanów o niskiej jakości, nie jest dostępny w tym pakiecie. Wszelkie błędy wykryte od czasu archiwizacji — w tym problemy z kompatybilnością z nowszymi środowiskami uruchomieniowymi .NET, zmienione zachowanie ładowania natywnych plików binarnych w systemie Linux lub kwestie związane z bezpieczeństwem w bibliotece C Tesseract — nie mają możliwości naprawy.

Nowe projekty, które dziś polegają na zależnościach NuGet od Tesseract, zaczynają się od pakietu, który otrzymał już swoją ostateczną aktualizację. Za dwanaście miesięcy ta zależność będzie o kolejny rok dalej od jakiejkolwiek konserwacji. Za trzy lata prawdopodobnie nie będzie działać na ówczesnych środowiskach uruchomieniowych .NET. Pakiet nadal będzie się instalował, a podstawowy interfejs API nadal będzie się kompilował, ale dług techniczny będzie się gromadził w sposób niewidoczny.

Praktyczna konsekwencja wykraczająca poza lukę w dokładności: jeśli zostanie opublikowany krytyczny CVE dla kodu C++ Tesseract 4.1.1, pakiet NuGet charlesw nie otrzyma poprawki. Jedynymi rozwiązaniami są rozgałęzienie i ponowne skompilowanie natywnych plików binarnych ze źródeł — co nie jest łatwym zadaniem — albo pogodzenie się z tym ryzykiem.

Podejście IronOCR

IronOCR zawiera Tesseract 5 z udoskonaleniami wprowadzonymi do procesu rozpoznawania, a biblioteka IronOCR jest regularnie aktualizowana. Ulepszenia dokładności wynikające z modelu Tesseract 5 są dostępne bez żadnych zmian w kodzie — zapewnia je aktualizacja pakietu. Podręcznik konfiguracji IronTesseract obejmuje aktualny interfejs API, który odzwierciedla aktywny rozwój, a nie zamrożoną wersję z 2021 roku.

W przypadku produkcyjnego OCR w aplikacji .NET poleganie na archiwalnej bibliotece stanowi ryzyko biznesowe, a nie tylko preferencję techniczną. Celem tego porównania jest rzetelna ocena tego ryzyka.

charlesw/tesseract podejście

Pakiet NuGet Tesseract zawiera natywne binaria dla najczęściej używanych platform wewnątrz swojego folderu runtimes/. Na stacji roboczej programisty korzystającej z domyślnego zachowania publikowania .NET SDK pliki binarne są automatycznie kopiowane do katalogu wyjściowego i wszystko działa. Problemy pojawiają się, gdy cele wdrożenia odbiegają od tego idealnego scenariusza:

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

Same pliki tessdata dodają kolejny krok wdrażania. Dla języka angielskiego eng.traineddata ma około 15 MB. Dla każdego dodatkowego języka, kolejny plik o wielkości 15 MB musi być pobrany z repozytorium GitHub Tesseract, zapisany w kontroli źródeł lub sklepie artefaktów wdrożeniowych, skonfigurowany do kopiowania do katalogu wyjściowego w .csproj i zweryfikowany jako obecny w każdym środowisku. Wpis .csproj wygląda następująco:

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

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

Zapomnij o tym wpisie w nowym projekcie, wdroż go do CI, a potok OCR zawiedzie w czasie wykonywania z błędem ścieżki — nie jest to błąd kompilacji. Błąd ujawnia się w środowisku produkcyjnym lub stagingowym, a nie w czasie kompilacji.

W systemie Linux na architekturze ARM64 — coraz bardziej istotnym w miarę jak agenci kompilacji AWS Graviton i Apple Silicon stają się standardem — archiwalny pakiet nie daje gwarancji zaktualizowanych plików binarnych. Ostatnia publikacja pakietu miała miejsce przed powszechnym wdrożeniem infrastruktury serwerowej ARM64.

Podejście IronOCR

IronOCR zawiera wszystkie natywne pliki binarne i angielskie dane tessdata w samym pakiecie NuGet. Nie ma plików tessdata do zarządzania, żadnych wpisów .csproj CopyToOutputDirectory i żadnej logiki ścieżki specyficznej dla platformy do napisania. Cała instalacja to:

// Install: dotnet add package IronOcr
// Nie tessdata download. Nie native binary configuration. Nie path management.

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

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

// Install: dotnet add package IronOcr
// Nie tessdata download. Nie native binary configuration. Nie path management.

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

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

' Install: dotnet add package IronOcr
' Nie tessdata download. Nie native binary configuration. Nie path management.

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

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

Kod ten działa bez zmian na systemach Windows x64, Linux x64, Linux ARM64, macOS x64 i macOS ARM64. Ten sam plik binarny można wdrożyć w Dockerze, Azure App Service i AWS Lambda bez żadnej logiki zależnej od platformy. Przewodnik wdrażania Docker oraz przewodnik wdrażania Linux dokumentują konkretne wymagania dla platform innych niż Windows, które są minimalne.

Dodatkowe języki instaluje się za pośrednictwem NuGet — bez pobierania plików i konfiguracji katalogów:

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

Różnica w złożoności wdrożenia nie jest marginalna. Zespoły utrzymującecharlesw/tesseractw potokach CI/CD z wieloma celami wdrożeniowymi rutynowo spędzają 4–8 godzin na debugowaniu problemów związanych ze ścieżkami i plikami binarnymi, które IronOCR całkowicie eliminuje. Aby uzyskać pełny przewodnik po odczytywaniu tekstu z obrazów bez utrudnień związanych z wdrażaniem, samouczek IronOCR obejmuje cały proces.

charlesw/tesseract podejście

W przypadku czystych skanów o wysokiej rozdzielczości Tesseract 4.1.1 daje wyniki porównywalne z Tesseract 5. Różnice pojawiają się w przypadku materiałów wejściowych o gorszej jakości: obrazów o niskiej rozdzielczości, lekko przekrzywionych dokumentów, faksów i zdjęć wydrukowanego tekstu. Model LSTM w Tesseract 4.1.1 nie korzystał z dodatkowych danych szkoleniowych i udoskonaleń architektury, które wprowadzono w Tesseract 5.

Co ważniejsze,charlesw/tesseractnie zapewnia żadnego przetwarzania wstępnego. Surowy obraz trafia bezpośrednio do silnika. W przypadku skanowania w rozdzielczości 150 DPI za pomocą konsumenckiego skanera płaskiego dokładność spada do 40–70%. W przypadku dokumentu z odchyleniem o 5 stopni dokładność może spaść poniżej 70%. W przypadku zdjęcia dokumentu wykonanego pod niewielkim kątem przy nierównomiernym oświetleniu dokładność może wynosić 10–40%:

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

Odzyskanie użytecznej dokładności wymaga procesu przetwarzania wstępnego — konwersji do skali szarości, wzmocnienia kontrastu, binarizacji, prostowania za pomocą transformacji Hougha lub profili projekcji, usuwania szumów oraz normalizacji DPI. Ten pipeline to 100–300 linii dodatkowego kodu używającego System.Drawing, SixLabors.ImageSharp, lub podobnych — z których żaden nie jest częścią pakietu Tesseract. Każdy etap przetwarzania wstępnego wymaga oddzielnej implementacji, testowania i dostosowania. Sam etap prostowania, poprawnie zaimplementowany przy użyciu transformacji Hougha, zajmuje ponad 50 wierszy.

Podejście IronOCR

IronOCR stosuje automatyczne przetwarzanie wstępne przed przekazaniem obrazu do silnika Tesseract 5. Ten sam skan o niskiej jakości, który zapewnia 40–70% dokładności w przypadku surowego charlesw/tesseract, zapewnia ponad 95% dokładności w przypadku IronOCR, ponieważ biblioteka normalizuje obraz, zanim silnik go zobaczy. Gdy potrzebna jest wyraźna kontrola, API przetwarzania wstępnego odzwierciedla etapy potoku bez konieczności niestandardowej implementacji:

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

Przewodnik po korekcji jakości obrazu dokumentuje pełen zestaw filtrów przetwarzania wstępnego oraz ich zastosowania. W przypadku dokumentów z kolorowym tłem lub nierównomiernym oświetleniem, przewodnik po korekcji kolorów obrazu zawiera informacje o dodatkowych filtrach. Oba przewodniki odzwierciedlają aktualny interfejs API — w przeciwieństwie do dokumentacji charlesw, która opisuje bibliotekę, która nie jest już aktualizowana.

W przypadku scenariuszy skanowania o niskiej jakości przykład OCR dla skanów o niskiej jakości pokazuje różnicę w dokładności przed i po przetworzeniu na konkretnych danych wejściowych.

charlesw/tesseract podejście

Zespoły wdrażającecharlesw/tesseractw wielu środowiskach gromadzą logikę warunkowego wdrażania, która nie ma nic wspólnego z OCR. Ścieżka do pliku tessdata różni się w zależności od środowiska. Zachowanie natywnego ładowania plików binarnych różni się w systemach Windows i Linux. Obrazy Docker wymagają jawnych instrukcji COPY i poleceń apt-get dla zależności Leptonica na niektórych podstawowych obrazach Linux:

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

Plik Dockerfile dla projektu wykorzystującegocharlesw/tesseractwymaga jawnego kopiowania plików tessdata i może wymagać instalacji pakietu Leptonica na poziomie systemu, w zależności od obrazu bazowego:

# 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"]

Ten plik Dockerfile osadza wiedzę operacyjną na temat modelu wdrażaniacharlesw/tesseractbezpośrednio w kodzie infrastruktury. Gdy zmienia się obraz bazowy lub dystrybucja Linuksa aktualizuje Leptonica, kompilacja się nie udaje. W przypadku pakietu archiwalnego jedynym rozwiązaniem jest utrzymanie niestandardowego, natywnego potoku kompilacji plików binarnych.

Podejście IronOCR

IronOCR nie posiada etapu tessdata COPY, nie wymaga instalacji pakietu systemowego dla Leptonica i nie zawiera logiki ścieżek zależnych od platformy. Przewodnik wdrażania Docker dla IronOCR wymaga jedynie standardowej instalacji libgdiplus dla obsługi System.Drawing na Linux — infrastruktury, której każda aplikacja .NET na Linux już potrzebuje:

# 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

# Nie tessdata COPY. Nie Leptonica apt-get. Nie native binary management.

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

Przewodnik wdrożeniowy AWS i przewodnik wdrożeniowy Azure mają ten sam schemat: jeden standardowy pakiet systemowy, a następnie aplikacja. Nie jest wymagany kod infrastruktury specyficzny dla biblioteki.

Projekty typu greenfield, które znalazły stary samouczek

Najczęściej spotykanym scenariuszem jest deweloper, który rozpoczyna nowy projekt, znajdując odpowiedź na Stack Overflow z 2019 lub 2020 roku albo wpis blogowy odnoszący się do charlesw/tesseract, instalując pakiet i odkrywając w połowie projektu, że jest on zarchiwizowany. W tym momencie zespół staje przed decyzją: kontynuować z zamrożoną zależnością lub przeprowadzić migrację, zanim baza kodu się powiększy. Zespoły, które zauważają status archiwizacji przed wysyłką, zazwyczaj natychmiast migrują — powierzchnia API jest na tyle mała, że migracja zcharlesw/tesseractdo IronOCR zajmuje zazwyczaj kilka godzin, a ryzyko związane z bieżącą konserwacją znika. Centrum samouczków IronOCR zawiera aktualne przykłady, które zastępują przestarzałe treści społecznościowe, które doprowadziły do powstania zależności charlesw/tesseract.

Wymagania dotyczące wdrażania na wielu platformach

Zespoły, które początkowo wdrożyłycharlesw/tesseractw systemie Windows, a następnie dodały cele dla systemu Linux — co stało się powszechne wraz ze wzrostem popularności Kubernetes i Docker — w pełni odczuły złożoność wdrażania natywnych plików binarnych. Konfigurowanie ścieżek tessdata, sprawdzanie dostępności Leptonica, zarządzanie instrukcjami Docker zależnymi od platformy: to wszystko szybko się kumuluje. Gdy docelowe środowisko wdrożeniowe obejmuje ARM64 (AWS Graviton ze względu na koszty, Apple Silicon dla CI), obsługa plików binarnych w archiwizowanym pakiecie staje się niepewna. Zespoły w takiej sytuacji rozważają IronOCR, gdy obciążenie związane ze wsparciem wdrożeniowym przewyższa koszt licencji komercyjnej. Przewodnik wdrożeniowy dla systemu Linux pokazuje, jak wygląda wdrożenie IronOCR w porównaniu: jest znacznie prostsze. Zobacz stronę licencyjną dla aktualnych stawek.

Dokumenty, które nie spełniają wymagań dotyczących dokładności

Zespoły korzystające zcharlesw/tesseractna czystych, kontrolowanych danych wejściowych — skanach dokumentów pisanych na maszynie o wysokiej rozdzielczości — widzą zadowalające wyniki i nie mają bezpośredniego powodu, aby zmieniać oprogramowanie. Sygnałem do działania jest nadejście dokumentów z prawdziwego świata: zeskanowanych formularzy od podmiotów zewnętrznych, faksów, zdjęć z urządzeń mobilnych, starszych materiałów drukowanych o pogorszonej jakości kontrastu. Bez wstępnego przetwarzania dokładnośćcharlesw/tesseractw przypadku tych danych wejściowych spada poniżej progów użyteczności. Budowanie potoku przetwarzania wstępnego w oparciu o zarchiwizowany pakiet oznacza inwestowanie czasu programistów w infrastrukturę, która obsługuje zależność bez przyszłości. W tym punkcie zwrotnym argumenty przemawiające za automatycznym przetwarzaniem wstępnym IronOCR i dokładnością Tesseract 5 stają się oczywiste.

Przeglądy bezpieczeństwa i zgodności

Audyty zależności w środowiskach podlegających regulacjom — opieka zdrowotna, finanse, administracja publiczna — oznaczają zarchiwizowane pakiety jako nieprawidłowości. Zależność, która nie może otrzymać poprawek bezpieczeństwa, stanowi ryzyko dla zgodności z przepisami, niezależnie od jej aktualnego statusu podatności. Pakietcharlesw/tesseractstanowi nakładkę na bibliotekę C++; żadne przyszłe luki CVE w kodzie C Tesseract 4.1.1 nie mają ścieżki naprawy poprzez pakiet NuGet. Zespoły ds. zgodności sprawdzające system zbudowany na archiwalnej zależności będą wymagały albo jej zastąpienia, albo udokumentowanego wyjątku. Zespoły, które napotykają ten problem podczas audytu bezpieczeństwa, wybierają IronOCR, aby usunąć to zgłoszenie, zamiast dokumentówać wyjątek w każdym cyklu audytowym.

Wymagania dotyczące dokładności Tesseract 5

Zespoły, które porównałycharlesw/tesseractpod kątem wymagań dotyczących dokładności i uznały Tesseract 4.1.1 za niewystarczający — szczególnie w przypadku tekstu odręcznego, skanów o niskiej jakości lub dokumentów z nietypowymi czcionkami — nie mogą zaktualizować silnika za pomocą zarchiwizowanego pakietu. Tesseract 5 nie jest dostępny bez zmiany bibliotek.IronOCR zapewnia dokładność na poziomie Tesseract 5, a dodatkowo oferuje automatyczne przetwarzanie wstępne, co jeszcze bardziej zwiększa dokładność. Różnica w jakości dokumentów o obniżonej rozdzielczości jest na tyle duża (40–70% w porównaniu z ponad 95% w przypadku skanów o niskiej rozdzielczości), że decyduje o migracji niezależnie od kwestii związanych z utrzymaniem.

Zastąpienie TesseractEngine przez IronTesseract

APIcharlesw/tesseractopiera się na konstruowaniu TesseractEngine z jawną ścieżką tessdata i łańcuchem kodu językowego.IronOCR zastępuje cały ten wzorzec konstrukcji konstruktorem bez argumentów. Konfiguracja silnika, która była domyślnie ustawiona w stałej TessDataPath i enumie EngineMode, staje się nieistotna —IronOCR zarządza inicjalizacją własnego silnika wewnętrznie:

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

Stała TessDataPath, folder tessdata oraz wpis .csproj CopyToOutputDirectory wszystkie zostają usunięte. Należy również usunąć wszelki kod rozpoznawania ścieżek zależny od platformy. Dokumentacja API IronTesseract obejmuje pełen zakres konfiguracji, jeśli konieczne jest dostosowanie na poziomie silnika wykraczające poza ustawienia domyślne.

Zastąpienie iteratora stron wynikami ustrukturyzowanymi

charlesw/tesseract udostępnia dane na poziomie słów za pomocą wzorca iteratora — page.GetIterator(), iter.Begin(), iter.Next() z wartościami enum PageIteratorLevel.IronOCR zastępuje to bezpośrednim dostępem do kolekcji w obiekcie wynikowym. Szablon iteratora usuwa; dane są bezpośrednio dostępne:

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

Przewodnik po wynikach odczytu obejmuje pełny model wyników strukturalnych — strony, akapity, wiersze, słowa i znaki — wszystkie dostępne bez zarządzania iteratorami.

Dodanie obsługi plików PDF

charlesw/tesseract nie obsługuje plików PDF. Projekty, które przetwarzają dokumenty PDF wraz z obrazami, zazwyczaj mają drugą zależność — PdfiumViewer, PDFtoImage lub podobną — która renderuje strony PDF do obiektów Bitmap przed przekazaniem ich do Tesseract. Tę bibliotekę pomocniczą i jej natywną zależność binarną można całkowicie usunąć podczas migracji do IronOCR:

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

Podręcznik dotyczący plików wejściowych w formacie PDF obejmuje wybór zakresu stron, pliki PDF chronione hasłem oraz pliki wyjściowe w formacie PDF z możliwością wyszukiwania — funkcje, które wymagały oddzielnych bibliotek i znacznej ilości kodu w ramach charlesw/tesseract.

Migracja pakietu językowego

Każdy język wcharlesw/tesseractwymagał osobnego pobrania pliku .traineddata, ręcznego przechowywania i jawnej konfiguracji wdrożenia. Migracja do pakietów językowych IronOCR polega na dodaniu pakietu NuGet dla każdego języka, bez żadnych innych zmian:

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

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

Przewodnik dotyczący wielu języków obejmuje rozpoznawanie wielu języków jednocześnie. Indeks języków zawiera listę wszystkich ponad 125 dostępnych pakietów językowych.