Dlaczego warto przejść z Tesseract OCR na IronOCR?

Typowe czynniki motywujące to eliminacja złożoności interoperacyjności COM, zastąpienie zarządzania licencjami opartego na plikach, uniknięcie rozliczeń za stronę, umożliwienie wdrażania w Dockerze/kontenerach oraz przyjęcie natywnego dla NuGet przepływu pracy, który integruje się ze standardowymi narzędziami .NET.

Jakie są główne zmiany w kodzie podczas migracji z Tesseract OCR do IronOCR?

Zastąp sekwencje inicjalizacji Tesseract OCR instancjonowaniem IronTesseract, usuń zarządzanie cyklem życia COM (jawne wzorce Create/Load/Close) i zaktualizuj nazwy właściwości wyników. W rezultacie znacznie zmniejsza się liczba powtarzających się linii kodu.

Jak zainstalować IronOCR, aby rozpocząć migrację?

Uruchom polecenie „Install-Package IronOcr” w konsoli menedżera pakietów lub „dotnet add package IronOcr” w interfejsie CLI. Pakiety językowe są oddzielnymi pakietami: na przykład „dotnet add package IronOcr.Languages.French” dla języka francuskiego.

Czy IronOCR dorównuje dokładnością OCR Tesseract OCR w przypadku standardowych dokumentów biznesowych?

IronOCR zapewnia wysoką dokładność w przypadku standardowych treści biznesowych, w tym faktur, umów, paragonów i formularzy wypełnionych na komputerze. Filtry przetwarzania wstępnego obrazu (prostowanie, usuwanie szumów, wzmacnianie kontrastu) dodatkowo poprawiają rozpoznawanie w przypadku pogorszonej jakości danych wejściowych.

W jaki sposób IronOCR obsługuje dane językowe, które Tesseract OCR instaluje oddzielnie?

Dane językowe w IronOCR są dystrybuowane jako pakiety NuGet. Polecenie „dotnet add package IronOcr.Languages.German” instaluje obsługę języka niemiećkiego. Nie wymaga to ręcznego umieszczania plików ani podawania ścieżek katalogów.

Czy migracja z Tesseract OCR do IronOCR wymaga zmian w infrastrukturze wdrożeniowej?

IronOCR wymaga mniej zmian w infrastrukturze niż Tesseract OCR. Nie ma ścieżek binarnych SDK, lokalizacji plików licencyjnych ani konfiguracji serwerów licencyjnych. Pakiet NuGet zawiera kompletny silnik OCR, a klucz licencyjny jest ciągiem znaków ustawionym w kodzie aplikacji.

Jak skonfigurować licencjonowanie IronOCR po migracji?

W kodzie uruchamiającym aplikację przypisz IronOcr.License.LicenseKey = „YOUR-KEY”. W Dockerze lub Kubernetesie zapisz klucz jako zmienną środowiskową i odczytaj go podczas uruchamiania. Użyj License.IsValidLicense do sprawdzenia ważności przed przyjęciem ruchu.

Czy IronOCR może przetwarzać pliki PDF w taki sam sposób jak Tesseract OCR?

Tak. IronOCR odczytuje zarówno natywne, jak i zeskanowane pliki PDF. Należy utworzyć instancję IronTesseract, wywołać ocr.Read(input), gdzie input jest ścieżką do pliku PDF lub obiektem OcrPdfInput, a następnie iterować strony OcrResult. Nie jest wymagany oddzielny proces renderowania plików PDF.

W jaki sposób IronOCR radzi sobie z wątkami podczas przetwarzania dużych ilości danych?

IronTesseract można bezpiecznie instancjonować dla każdego wątku. Uruchom jedną instancję na wątek w Parallel.ForEach lub puli zadań, uruchom OCR równolegle i usuń każdą instancję po zakończeniu. Nie jest wymagany żaden stan globalny ani blokowanie.

Jakie formaty wyjściowe obsługuje IronOCR po wyodrębnieniu tekstu?

IronOCR zwraca ustrukturyzowane wyniki, w tym tekst, współrzędne słów, wyniki pewności i strukturę strony. Opcje eksportu obejmują zwykły tekst, PDF z możliwością wyszukiwania oraz obiekty wyników ustrukturyzowanych do dalszego przetwarzania.

Czy ceny IronOCR są bardziej przewidywalne niż Tesseract OCR w przypadku skalowania obciążeń?

IronOCR stosuje licencję wieczystą z opłatą ryczałtową, bez opłat za stronę lub wolumen. Niezależnie od tego, czy przetwarzasz 10 000, czy 10 milionów stron, koszt licencji pozostaje stały. Opcje licencji wolumenowych i zespołowych znajdują się na stronie z cennikiem IronOCR.

Co stanie się z moimi istniejącymi testami po migracji z Tesseract OCR do IronOCR?

Testy sprawdzające wyodrębnioną treść tekstową powinny nadal przechodzić pomyślnie po migracji. Testy weryfikujące wzorce wywołań API lub cykl życia obiektów COM będą wymagały aktualizacji, aby odzwierciedlały prostszy model inicjalizacji i wyników IronOCR.

Biblioteka OCR dla C#

Explore IronOCR Bezpłatna próba

OCR w 1 linii kodu

Zobacz wszystkie przykłady kodu %s

using IronOcr;

string imageText = new IronTesseract().Read(@"images\image.png").Text;

using IronOcr;

string imageText = new IronTesseract().Read(@"images\image.png").Text;

PM >Install-Package IronOcr

Install-Package IronOcr

FILMY

Migracja z Tesseract do IronOCR

Kannapat Udonpant

Updated: 1 sierpnia 2026

Ten przewodnik oferuje bezpośrednią ścieżkę migracji z pakietu charlesw Tesseract NuGet na IronOCR. Zawiera on konkretne kroki niezbędne do wyeliminowania zarządzania folderem tessdata, zastąpienia wzorców inicjalizacji TesseractEngine i Pix, dodania wbudowanego potoku przetwarzania wstępnego oraz odblokowania wsparcia dla natywnego PDF — bez powielania materiału już omówionego w artykule porównawczym dla tej biblioteki.

Dlaczego warto przejść z Tesseract

Pakiet charlesw Tesseract udostępnia prawdziwą funkcję OCR, a jego 8 milionów pobrań z NuGet to potwierdza. Problem nie leży w silniku — leży w infrastrukturze, którą musisz zbudować wokół silnika, zanim będziesz mógł dostarczyć produkt o jakości produkcyjnej. Cztery konkretne problemy decydują o większości decyzji dotyczących migracji.

Zarządzanie folderem tessdata staje się bardziej skomplikowane z każdym środowiskiem. Zanim można rozpoznać pojedyncze słowo, ścieżka tessdata musi istnieć, być wypełniona odpowiednimi plikami .traineddata dla każdego języka, którego potrzebuje aplikacja, oraz być dostępna dokładnie w ścieżce przekazanej do TesseractEngine. Oznacza to utworzenie oddzielnych folderów dla maszyn programistycznych, kompilacji CI, serwerów stagingowych, hostów produkcyjnych i kontenerów Docker. Brakujący plik generuje TesseractException: Failed to initialise tesseract engine w czasie wykonywania — po wdrożeniu — z komunikatem, który nie zawsze identyfikuje, którego pliku brakuje. Każde nowe środowisko to kolejna okazja do ponowienia tej porażki.

Tesseract 4.1.1 to koniec drogi. Owijka charlesw jest przypisana do Tesseract 4.1.1, wydanego w 2019 roku. W Tesseract 5.x wprowadzono ulepszenia modelu LSTM, które zapewniają mierzalnie lepszą dokładność w przypadku niektórych typów dokumentów. Ta wersja nie jest dostępna w tym pakiecie, a tempo utrzymania owijki znacznie spadło od 2021 roku. Zespoły, którym zależy na zachowaniu tej samej dokładności, co w aktualnych wersjach Tesseract, nie mają możliwości aktualizacji poprzez opakowanie charlesw.

Brak przetwarzania wstępnego oznacza brak niezawodności w przypadku dokumentów z prawdziwego świata. Tesseract oczekuje czystych, wysokiej rozdzielczości i prawidłowo zorientowanych danych wejściowych. Nie stosuje się wbudowanej korekcji dla przekrzywienia, szumu, niskiej rozdzielczości (DPI) ani kolorowego tła. Ręczne budowanie potoku przetwarzania wstępnego — konwersja na skalę szarości, zwiększanie kontrastu, binaryzacja, filtrowanie medianowe szumów, korekta pochyleń — zajmuje około 180 linii kodu przy użyciu System.Drawing.Common (tylko dla Windows) lub wymaga pobrania OpenCvSharp4 dla poprawnej korekty pochyleń transformacją Hougha. Następnie należy utrzymywać tę ścieżkę przetwarzania, ponieważ nowe źródła dokumentów wprowadzają skrajne przypadki.

PDF to dodatek wymagający drugiego łańcucha zależności. Umowy, faktury, wyciągi bankowe i dokumenty dotyczące zgodności przychodzą w formacie PDF. Tesseract nie może otworzyć pliku PDF. Wypełnienie tej luki wymaga oddzielnej biblioteki do renderowania plików PDF — PdfiumViewer, PDFtoImage lub Docnet.Core — z których każda posiada własne pliki binarne, specyficzne dla platformy procedury wdrażania oraz kwestie licencyjne. GhostScript wiąże się z konsekwencjami wynikającymi z licencji AGPL. Pliki PDF chronione hasłem stanowią kolejną bibliotekę. Zespoły zarządzające trzema oddzielnymi łańcuchami zależności natywnych w wielu środowiskach osiągają próg konserwacji, który skłania do bezpośredniej oceny alternatyw w postaci pojedynczych pakietów.

Projekt silnika niewyposażonego w zabezpieczenia wielowątkowe ogranicza równoległe przetwarzanie. Instancja TesseractEngine nie może być współdzielona pomiędzy wątkami. Standardowy wzorzec przetwarzania równoległego tworzy jeden silnik na wątek, ładując 40–100 MB danych modelu językowego na instancję. Osiem równoległych wątków oznacza 320-800 MB narzutu na inicjalizację silnika, zanim jakiekolwiek dokumenty zostaną przetworzone. Nie jest to błąd — jest to zamierzone działanie API niezabezpieczonego przed wielowątkowością — ale koszt pamięci jest realny i rośnie wraz ze wzrostem rozmiarów partii.

Podstawowy problem

Każda aplikacja Tesseract uruchamia się w ten sam sposób: poprzez określenie ścieżki do pliku tessdata, która musi być poprawna na każdym komputerze, na którym aplikacja jest uruchamiana.

Podejście Tesseract:

// TessDataPath must exist and be populated — breaks on first clean deployment
private const string TessDataPath = @"./tessdata";

public static string ExtractText(string imagePath)
{
    // Runtime failure if eng.traineddata is missing from TessDataPath
    if (!Directory.Exists(TessDataPath))
        throw new DirectoryNotFoundException(
            $"Tessdata not found at {TessDataPath}. " +
            "Download from https://github.com/tesseract-ocr/tessdata");

    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img   = Pix.LoadFromFile(imagePath);  // Leptonica Pix object
    using var page  = engine.Process(img);
    return page.GetText();
}

// TessDataPath must exist and be populated — breaks on first clean deployment
private const string TessDataPath = @"./tessdata";

public static string ExtractText(string imagePath)
{
    // Runtime failure if eng.traineddata is missing from TessDataPath
    if (!Directory.Exists(TessDataPath))
        throw new DirectoryNotFoundException(
            $"Tessdata not found at {TessDataPath}. " +
            "Download from https://github.com/tesseract-ocr/tessdata");

    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img   = Pix.LoadFromFile(imagePath);  // Leptonica Pix object
    using var page  = engine.Process(img);
    return page.GetText();
}

Podejście IronOCR:

// No tessdata folder. No path. No file check. Just OCR.
var text = new IronTesseract().Read("document.jpg").Text;

// No tessdata folder. No path. No file check. Just OCR.
var text = new IronTesseract().Read("document.jpg").Text;

Cała stała TessDataPath, strażnik Directory.Exists, obiekt Pix oraz trójpoziomowe zagnieżdżenie using znikają. Dane językowe są osadzone w pakiecie NuGet.

##IronOCR a Tesseract: porównanie funkcji

Poniższa tabela przedstawia funkcje, które mają największe znaczenie przy podejmowaniu decyzji dotyczących migracji.

Funkcja	Tesseract (charlesw)	IronOCR
Pakiet NuGet	`Tesseract`	`IronOcr`
Wersja silnika Tesseract	4.1.1 (2019, przypięte)	Zoptymalizowany Tesseract 5.x
Zarządzanie danymi Tessdata	Pobieranie folderu z instrukcją + plików	W pakiecie — zero konfiguracji
Pakiety językowe	Ręczne pobieranie `.traineddata`.	Pakiet NuGet dla każdego języka
Dostępne języki	100+ (ręcznie)	125+ (NuGet)
Wielojęzyczne tłumaczenie symultaniczne	`"eng+fra+deu"` ciąg znaków.	`OcrLanguage.French + OcrLanguage.German`
Wstępne przetwarzanie obrazów	Podręcznik (~180 wierszy)	Wbudowane metody jednowierszowe
Wyrównanie	Podręcznik (wymagana transformacja Hougha)	`input.Deskew()`
DeNoise	Ręcznie (filtr medianowy)	`input.DeNoise()`
Kontrast / Binarizacja	Ręczna iteracja pikseli	`input.Contrast()`, `input.Binarize()`
Głębokie usuwanie szumów	Niedostępne	`input.DeepCleanBackgroundNoise()`
Plik wejściowy PDF	Brak — wymaga biblioteki zewnętrznej	Język ojczysty (zeskanowane, cyfrowe, mieszane)
Plik PDF chroniony hasłem	Wymagana biblioteka deszyfrująca	`input.LoadPdf(path, Password: "...")`
Wielostronicowy plik TIFF	Ręczna iteracja ramki	`input.LoadImageFrames()`
Wynik w formacie PDF z możliwością wyszukiwania	Nieobsługiwane	`result.SaveAsSearchablePdf()`
Strukturalny dostęp do wyników	`ResultIterator` pętla.	`result.Pages`, `.Paragraphs`, `.Words`
Bezpieczeństwo wątków	Nie jest bezpieczne dla wątków	Bezpieczna dla wątków pojedyncza instancja
Odczytywanie BarCode	Nieobsługiwane	`ocr.Configuration.ReadBarCodes = true`
Wielopłatformowe	Wymagane natywne biblioteki DLL dla każdej platformy	Pojedynczy pakiet NuGet, wszystkie platformy
Wdrożenie Docker	apt-get + tessdata KROKI KOPIOWANIA	Brak dodatkowych kroków
Licencjonowanie	Apache 2.0 (bezpłatna)	Wieczysta ($999 Lite / 1 499 USD Pro / 2 999 USD Enterprise).
Wsparcie komercyjne	Tylko dla społeczności	Tak (e-mail + poziomy priorytetów)

Szybki start: Migracja z Tesseract do IronOCR

Krok 1: Zastąp pakiet NuGet

Usuń opakowanie charlesw Tesseract:

dotnet remove package Tesseract

dotnet remove package Tesseract

SHELL

Zainstaluj IronOCR z NuGet:

> dotnet add package IronOcr

dotnet add package IronOcr

Pakiety językowe instaluje się w razie potrzeby jako oddzielne pakiety:

> dotnet add package IronOcr.Languages.French, IronOcr.Languages.German

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

Krok 2: Aktualizacja przestrzeni nazw

Zamień przestrzeń nazw Tesseract na przestrzeń nazw IronOCR:

// Before
using Tesseract;

// After
using IronOcr;

// Before
using Tesseract;

// After
using IronOcr;

Krok 3: Inicjalizacja licencji

Dodaj inicjalizację licencji raz przy uruchamianiu aplikacji, przed jakimikolwiek wywołaniami IronTesseract:

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

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

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

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

Bezpłatna wersja próbna działa bez klucza podczas fazy rozwoju. Wdrożenia produkcyjne wymagają ważnego klucza z strony licencyjnej.

Przykłady migracji kodu

Eliminacja ścieżki Tessdata i inicjalizacja silnika

Najbardziej natychmiastową zmianą jest usunięcie inicjalizacji TesseractEngine i całego kodu walidacji tessdata, który ją otacza.

Podejście Tesseract:

// Every class that uses OCR must handle this initialization block
private const string TessDataPath = @"./tessdata";

public string RecognizeInvoiceNumber(string imagePath)
{
    // Check tessdata presence — missing file = silent runtime failure
    foreach (var lang in new[] { "eng" })
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
    }

    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);

    // Pix is a Leptonica wrapper type — not a standard .NET image
    using var img  = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);

    string text = page.GetText();
    float  conf = page.GetMeanConfidence();

    return conf > 0.7f ? text : string.Empty;
}

// Every class that uses OCR must handle this initialization block
private const string TessDataPath = @"./tessdata";

public string RecognizeInvoiceNumber(string imagePath)
{
    // Check tessdata presence — missing file = silent runtime failure
    foreach (var lang in new[] { "eng" })
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
    }

    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);

    // Pix is a Leptonica wrapper type — not a standard .NET image
    using var img  = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);

    string text = page.GetText();
    float  conf = page.GetMeanConfidence();

    return conf > 0.7f ? text : string.Empty;
}

Podejście IronOCR:

using IronOcr;

public string RecognizeInvoiceNumber(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);

    // Confidence property returns 0-100 double
    return result.Confidence > 70 ? result.Text : string.Empty;
}

using IronOcr;

public string RecognizeInvoiceNumber(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);

    // Confidence property returns 0-100 double
    return result.Confidence > 70 ? result.Text : string.Empty;
}

Strażnik FileNotFoundException, stała tessdata, obiekt Pix i trójpoziomowe zagnieżdżenie znikają. IronTesseract jest tworzony bez argumentów, ponieważ dane językowe są osadzone. Jeśli potrzebujesz zachowania innego niż domyślne, zapoznaj się z przewodnikiem konfiguracji IronTesseract, a jeśli chcesz uzyskać pełny dostęp do API pewności, zapoznaj się z przewodnikiem po wynikach pewności.

Przetwarzanie wielostronicowych plików TIFF z wykorzystaniem potoku przetwarzania wstępnego

Pliki TIFF z wieloma ramkami — powszechne w archiwach zeskanowanych dokumentów i systemach faksowych — wymagają wyraźnej iteracji ramek w Tesseract.IronOCRładuje wszystkie ramki w jednym wywołaniu i jednolicie stosuje proces przetwarzania wstępnego.

Podejście Tesseract:

using Tesseract;
using System.Drawing;
using System.Drawing.Imaging;

private const string TessDataPath = @"./tessdata";

public static string ExtractFromMultiPageTiff(string tiffPath)
{
    var allText = new System.Text.StringBuilder();

    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var tiffImage = Image.FromFile(tiffPath);

    int frameCount = tiffImage.GetFrameCount(FrameDimension.Page);

    for (int i = 0; i < frameCount; i++)
    {
        tiffImage.SelectActiveFrame(FrameDimension.Page, i);

        // Must save each frame to disk — Pix.LoadFromFile requires a path
        string tempPath = Path.GetTempFileName() + ".png";
        try
        {
            tiffImage.Save(tempPath, ImageFormat.Png);

            using var img  = Pix.LoadFromFile(tempPath);
            using var page = engine.Process(img);
            allText.AppendLine(page.GetText());
        }
        finally
        {
            File.Delete(tempPath); // Uncleaned temp files fill disk on failure
        }
    }

    return allText.ToString();
}

using Tesseract;
using System.Drawing;
using System.Drawing.Imaging;

private const string TessDataPath = @"./tessdata";

public static string ExtractFromMultiPageTiff(string tiffPath)
{
    var allText = new System.Text.StringBuilder();

    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var tiffImage = Image.FromFile(tiffPath);

    int frameCount = tiffImage.GetFrameCount(FrameDimension.Page);

    for (int i = 0; i < frameCount; i++)
    {
        tiffImage.SelectActiveFrame(FrameDimension.Page, i);

        // Must save each frame to disk — Pix.LoadFromFile requires a path
        string tempPath = Path.GetTempFileName() + ".png";
        try
        {
            tiffImage.Save(tempPath, ImageFormat.Png);

            using var img  = Pix.LoadFromFile(tempPath);
            using var page = engine.Process(img);
            allText.AppendLine(page.GetText());
        }
        finally
        {
            File.Delete(tempPath); // Uncleaned temp files fill disk on failure
        }
    }

    return allText.ToString();
}

Podejście IronOCR:

using IronOcr;

public static string ExtractFromMultiPageTiff(string tiffPath)
{
    using var input = new OcrInput();
    input.LoadImageFrames(tiffPath);  // Loads all frames at once
    input.Deskew();                   // Applied to every frame uniformly
    input.DeNoise();

    var result = new IronTesseract().Read(input);
    return result.Text;
}

using IronOcr;

public static string ExtractFromMultiPageTiff(string tiffPath)
{
    using var input = new OcrInput();
    input.LoadImageFrames(tiffPath);  // Loads all frames at once
    input.Deskew();                   // Applied to every frame uniformly
    input.DeNoise();

    var result = new IronTesseract().Read(input);
    return result.Text;
}

Bez iteracji ramki. Nie tworzyć plików tymczasowych. Bez logiki czyszczenia. Potok przetwarzania wstępnego ma zastosowanie do każdej klatki bez dodatkowej pętli. Przewodnik dotyczący plików wejściowych TIFF i GIF szczegółowo omawia obsługę wielu klatek, w tym selektywne zakresy klatek dla dużych plików archiwalnych.

Generowanie plików PDF z możliwością wyszukiwania

Konwersja zeskanowanego pliku PDF do formatu PDF z możliwością wyszukiwania wymaga, aby Tesseract renderował każdą stronę jako obraz (za pomocą zewnętrznej biblioteki PDF), uruchamiał OCR, a następnie odtwarzał plik PDF z warstwą tekstową — jest to wieloetapowy proces wykorzystujący wiele bibliotek.IronOCR obsługuje dane wejściowe, OCR i dane wyjściowe w jednym potoku.

Podejście Tesseract:

// Requires: PdfiumViewer + Tesseract + a PDF writer library (iText, PdfSharp)
// Each library adds its own native dependencies and license considerations

using Tesseract;
// using PdfiumViewer;  // Comment: must add NuGet + deploy native pdfium.dll
// using iText.Kernel.Pdf;  // Comment: AGPL or commercial license required

private const string TessDataPath = @"./tessdata";

public static void CreateSearchablePdf(string inputPdfPath, string outputPdfPath)
{
    // Step 1: Render PDF pages to images (requires PdfiumViewer)
    // Step 2: Run OCR on each image (Tesseract)
    // Step 3: Write text positions back into PDF (requires iText or PDFsharp)
    //
    // Total: ~150 lines across three libraries
    // Native binaries required: tesseract*.dll, leptonica*.dll, pdfium.dll
    // License risk: iText is AGPL unless you purchase a commercial license

    throw new NotImplementedException(
        "Requires PdfiumViewer + Tesseract + a PDF writer. " +
        "No single-package solution exists with this stack.");
}

// Requires: PdfiumViewer + Tesseract + a PDF writer library (iText, PdfSharp)
// Each library adds its own native dependencies and license considerations

using Tesseract;
// using PdfiumViewer;  // Comment: must add NuGet + deploy native pdfium.dll
// using iText.Kernel.Pdf;  // Comment: AGPL or commercial license required

private const string TessDataPath = @"./tessdata";

public static void CreateSearchablePdf(string inputPdfPath, string outputPdfPath)
{
    // Step 1: Render PDF pages to images (requires PdfiumViewer)
    // Step 2: Run OCR on each image (Tesseract)
    // Step 3: Write text positions back into PDF (requires iText or PDFsharp)
    //
    // Total: ~150 lines across three libraries
    // Native binaries required: tesseract*.dll, leptonica*.dll, pdfium.dll
    // License risk: iText is AGPL unless you purchase a commercial license

    throw new NotImplementedException(
        "Requires PdfiumViewer + Tesseract + a PDF writer. " +
        "No single-package solution exists with this stack.");
}

Podejście IronOCR:

using IronOcr;

public static void CreateSearchablePdf(string inputPdfPath, string outputPdfPath)
{
    using var input = new OcrInput();
    input.LoadPdf(inputPdfPath);
    input.Deskew();    // Correct scanned page skew before OCR
    input.DeNoise();   // Remove scanner artifacts

    var result = new IronTesseract().Read(input);
    result.SaveAsSearchablePdf(outputPdfPath);
}

using IronOcr;

public static void CreateSearchablePdf(string inputPdfPath, string outputPdfPath)
{
    using var input = new OcrInput();
    input.LoadPdf(inputPdfPath);
    input.Deskew();    // Correct scanned page skew before OCR
    input.DeNoise();   // Remove scanner artifacts

    var result = new IronTesseract().Read(input);
    result.SaveAsSearchablePdf(outputPdfPath);
}

Jedno wywołanie metody generuje plik PDF z możliwością wyszukiwania i osadzoną warstwą tekstową. Brak zewnętrznej biblioteki PDF, brak natywnego pliku binarnego pdfium, brak powiązań licencyjnych z zależnościami AGPL. Przewodnik w formacie PDF z funkcją wyszukiwania dokumentuje format wyjściowy, a przykład OCR dla plików PDF przedstawia kompletny proces przetwarzania zeskanowanego dokumentu. Aby uzyskać szerszy kontekst dotyczący możliwości IronOCR w zakresie przetwarzania plików PDF, strona poświęcona przypadkom użycia OCR dla plików PDF omawia wzorce architektury produkcyjnej.

Pobieranie danych strukturalnych ze skanowanych dokumentów

Tesseract udostępnia dane na poziomie słowa przez ResultIterator, która wymaga pętli do/while z ręcznym wydobywaniem granic.IronOCR udostępnia hierarchię dokumentu — strony, akapity, wiersze, słowa — jako silnie typowane kolekcje z już wypełnionymi współrzędnymi.

Podejście Tesseract:

using Tesseract;

private const string TessDataPath = @"./tessdata";

public static void ExtractStructuredData(string imagePath)
{
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img    = Pix.LoadFromFile(imagePath);
    using var page   = engine.Process(img);
    using var iter   = page.GetIterator();

    iter.Begin();
    do
    {
        if (iter.IsAtBeginningOf(PageIteratorLevel.Para))
            Console.WriteLine("-- New Paragraph --");

        if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
        {
            string word       = iter.GetText(PageIteratorLevel.Word);
            float  confidence = iter.GetConfidence(PageIteratorLevel.Word);
            Console.WriteLine(
                $"Word: '{word?.Trim()}' " +
                $"at ({bounds.X1},{bounds.Y1})-({bounds.X2},{bounds.Y2}) " +
                $"conf={confidence:P0}");
        }
    }
    while (iter.Next(PageIteratorLevel.Word));
}

using Tesseract;

private const string TessDataPath = @"./tessdata";

public static void ExtractStructuredData(string imagePath)
{
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img    = Pix.LoadFromFile(imagePath);
    using var page   = engine.Process(img);
    using var iter   = page.GetIterator();

    iter.Begin();
    do
    {
        if (iter.IsAtBeginningOf(PageIteratorLevel.Para))
            Console.WriteLine("-- New Paragraph --");

        if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
        {
            string word       = iter.GetText(PageIteratorLevel.Word);
            float  confidence = iter.GetConfidence(PageIteratorLevel.Word);
            Console.WriteLine(
                $"Word: '{word?.Trim()}' " +
                $"at ({bounds.X1},{bounds.Y1})-({bounds.X2},{bounds.Y2}) " +
                $"conf={confidence:P0}");
        }
    }
    while (iter.Next(PageIteratorLevel.Word));
}

Podejście IronOCR:

using IronOcr;

public static void ExtractStructuredData(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);

    foreach (var page in result.Pages)
    {
        Console.WriteLine($"Page {page.PageNumber} — confidence: {result.Confidence}%");

        foreach (var paragraph in page.Paragraphs)
        {
            Console.WriteLine($"  Paragraph at ({paragraph.X},{paragraph.Y}):");
            Console.WriteLine($"  {paragraph.Text}");

            foreach (var word in paragraph.Words)
            {
                Console.WriteLine(
                    $"    Word: '{word.Text}' " +
                    $"at ({word.X},{word.Y}) " +
                    $"size {word.Width}x{word.Height} " +
                    $"conf={word.Confidence:P0}");
            }
        }
    }
}

using IronOcr;

public static void ExtractStructuredData(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);

    foreach (var page in result.Pages)
    {
        Console.WriteLine($"Page {page.PageNumber} — confidence: {result.Confidence}%");

        foreach (var paragraph in page.Paragraphs)
        {
            Console.WriteLine($"  Paragraph at ({paragraph.X},{paragraph.Y}):");
            Console.WriteLine($"  {paragraph.Text}");

            foreach (var word in paragraph.Words)
            {
                Console.WriteLine(
                    $"    Word: '{word.Text}' " +
                    $"at ({word.X},{word.Y}) " +
                    $"size {word.Width}x{word.Height} " +
                    $"conf={word.Confidence:P0}");
            }
        }
    }
}

Pętla ResultIterator całkowicie znika. Hierarchia dokumentu to zbiór kolekcji, które można wyliczyć — bez stanu iteratora, bez ręcznego śledzenia poziomów, bez wyodrębniania prostokąta ograniczającego przez parametr wyjściowy. Każdy obiekt słowny posiada własne współrzędne i poziom pewności. Dokumentacja wyników odczytu opisuje każdy poziom hierarchii, a dokumentacja API OcrResult zawiera listę wszystkich dostępnych właściwości.

Wielojęzyczne OCR bez zarządzania plikami Tessdata

Dodanie języka do aplikacji Tesseract oznacza pobranie pliku .traineddata, umieszczenie go w folderze tessdata, zaktualizowanie każdego manifestu wdrożenia obejmującego ten folder oraz zmodyfikowanie ciągu inicjalizacji silnika. W przypadku IronOCR jest to pojedyncze odwołanie do pakietu NuGet.

Podejście Tesseract:

using Tesseract;

private const string TessDataPath = @"./tessdata";

public static string ExtractFromEuropeanDocument(string imagePath)
{
    // Before this call works, these files must exist:
    // ./tessdata/eng.traineddata  (~15 MB, from GitHub)
    // ./tessdata/fra.traineddata  (~15 MB, from GitHub)
    // ./tessdata/deu.traineddata  (~15 MB, from GitHub)
    // ./tessdata/spa.traineddata  (~15 MB, from GitHub)
    // Total: ~60 MB to download, version-match, and deploy to every environment

    foreach (var lang in new[] { "eng", "fra", "deu", "spa" })
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
            throw new FileNotFoundException(
                $"Download {lang}.traineddata from " +
                "https://github.com/tesseract-ocr/tessdata " +
                $"and place in {TessDataPath}");
    }

    // Language string is a concatenation — order affects recognition priority
    using var engine = new TesseractEngine(TessDataPath, "eng+fra+deu+spa", EngineMode.Default);
    using var img    = Pix.LoadFromFile(imagePath);
    using var page   = engine.Process(img);
    return page.GetText();
}

using Tesseract;

private const string TessDataPath = @"./tessdata";

public static string ExtractFromEuropeanDocument(string imagePath)
{
    // Before this call works, these files must exist:
    // ./tessdata/eng.traineddata  (~15 MB, from GitHub)
    // ./tessdata/fra.traineddata  (~15 MB, from GitHub)
    // ./tessdata/deu.traineddata  (~15 MB, from GitHub)
    // ./tessdata/spa.traineddata  (~15 MB, from GitHub)
    // Total: ~60 MB to download, version-match, and deploy to every environment

    foreach (var lang in new[] { "eng", "fra", "deu", "spa" })
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
            throw new FileNotFoundException(
                $"Download {lang}.traineddata from " +
                "https://github.com/tesseract-ocr/tessdata " +
                $"and place in {TessDataPath}");
    }

    // Language string is a concatenation — order affects recognition priority
    using var engine = new TesseractEngine(TessDataPath, "eng+fra+deu+spa", EngineMode.Default);
    using var img    = Pix.LoadFromFile(imagePath);
    using var page   = engine.Process(img);
    return page.GetText();
}

Podejście IronOCR:

// Install language packs once per project:
// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.German
// dotnet add package IronOcr.Languages.Spanish
using IronOcr;

public static string ExtractFromEuropeanDocument(string imagePath)
{
    var ocr = new IronTesseract();
    ocr.Language = OcrLanguage.English;
    ocr.AddSecondaryLanguage(OcrLanguage.French);
    ocr.AddSecondaryLanguage(OcrLanguage.German);
    ocr.AddSecondaryLanguage(OcrLanguage.Spanish);

    return ocr.Read(imagePath).Text;
}

// Install language packs once per project:
// dotnet add package IronOcr.Languages.French
// dotnet add package IronOcr.Languages.German
// dotnet add package IronOcr.Languages.Spanish
using IronOcr;

public static string ExtractFromEuropeanDocument(string imagePath)
{
    var ocr = new IronTesseract();
    ocr.Language = OcrLanguage.English;
    ocr.AddSecondaryLanguage(OcrLanguage.French);
    ocr.AddSecondaryLanguage(OcrLanguage.German);
    ocr.AddSecondaryLanguage(OcrLanguage.Spanish);

    return ocr.Read(imagePath).Text;
}

Folder tessdata, pętla istnienia pliku, konkatenacja ścieżki oraz aktualizacje manifestu wdrożenia są zastąpione przez linijki PackageReference w .csproj. Dodanie języka do Docker oznacza jeden dodatkowy dotnet add package — nie jest to krok COPY w Dockerfile. Przewodnik wielojęzyczny obejmuje pełny katalog 125+ języków oraz zestawów znakowych CJK, a indeks języków zawiera listę każdego dostępnego pakietu językowego.

Dokumentacja API Tesseract do IronOCR

Tesseract (charlesw)	IronOCR
`new TesseractEngine(tessDataPath, "eng", EngineMode.Default)`	`new IronTesseract()`
`Pix.LoadFromFile(path)`	`input.LoadImage(path)` lub `ocr.Read(path)`.
`Pix.LoadFromMemory(bytes)`	`input.LoadImage(bytes)`
`engine.Process(img)`	`ocr.Read(input)`
`page.GetText()`	`result.Text`
`page.GetMeanConfidence()`	`result.Confidence`
`page.GetHOCRText(0)`	`result.SaveAsHocrFile(path)`
`engine.Process(img, tessRect)`	`input.LoadImage(path, new CropRectangle(x, y, w, h))`
`page.GetIterator()`	`result.Pages` / `result.Paragraphs` / `result.Words`.
`iter.GetText(PageIteratorLevel.Word)`	`result.Words[i].Text`
`iter.GetConfidence(PageIteratorLevel.Word)`	`result.Words[i].Confidence`
`iter.TryGetBoundingBox(PageIteratorLevel.Word, out bounds)`	`word.X`, `word.Y`, `word.Width`, `word.Height`
`"eng+fra+deu"` ciąg językowy.	`ocr.AddSecondaryLanguage(OcrLanguage.French)`
Folder Tessdata + pliki `.traineddata`.	Pakiet językowy NuGet (`IronOcr.Languages.French`).
Nie dotyczy — wymaga PdfiumViewer lub podobnego oprogramowania	`input.LoadPdf(path)`
N/A — wymaga biblioteki deszyfrującej	`input.LoadPdf(path, Password: "secret")`
Nie dotyczy — wymaga iText lub PDFSharp	`result.SaveAsSearchablePdf(outputPath)`
N/A — ręczny potok System.Drawing	`input.Deskew()`, `input.DeNoise()`, `input.Binarize()`
N/D — silnik na wątek w `Parallel.ForEach`.	Pojedynczy `IronTesseract` współdzielony przez wszystkie wątki.
N/A — nieobsługiwane	`ocr.Configuration.ReadBarCodes = true`

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Odwołania do ścieżek Tessdata pozostają po migracji

Tesseract: Stałe TessDataPath, strażnicy Directory.Exists(TessDataPath) oraz kontrole File.Exists(Path.Combine(TessDataPath, lang + ".traineddata")) pojawiają się w całym kodzie źródłowym i w plikach projektowych jako elementy build <Content Include="tessdata\**">.

Rozwiązanie: Wyszukaj wszystkie wystąpienia i usuń je wraz z samym folderem tessdata:

# Find all tessdata references in source
grep -r "TessDataPath\|tessdata\|traineddata" --include="*.cs" .
grep -r "tessdata" --include="*.csproj" .

# Find all tessdata references in source
grep -r "TessDataPath\|tessdata\|traineddata" --include="*.cs" .
grep -r "tessdata" --include="*.csproj" .

SHELL

Po usunięciu stałych ścieżek i zabezpieczeń plików usuń folder tessdata z projektu. Usuń jakiekolwiek linie <Content Include="tessdata\**" CopyToOutputDirectory="..." /> z plików .csproj. Linie COPY ./tessdata w Dockerfile i deklaracje zmiennych środowiskowych ENV TESSDATA_PREFIX również można bezpiecznie usunąć.

Problem 2: Nie można rozpoznać typu obiektu Pix

Tesseract: Pix jest typem opakowania obrazu Leptonica z przestrzeni nazw Tesseract. Odwołania pojawiają się w deklaracjach zmiennych (using var img = Pix.LoadFromFile(...)), sygnaturach metod, które akceptują parametry Pix, i w każdym kodzie, który wywołuje Pix.LoadFromMemory() lub Pix.LoadFromBitmap().

Rozwiązanie: Zamień Pix.LoadFromFile(path) na input.LoadImage(path) w instancji OcrInput. Zamień Pix.LoadFromMemory(bytes) na input.LoadImage(bytes). Klasa OcrInput akceptuje ścieżki plików, tablice bajtów, strumienie i obiekty System.Drawing.Bitmap bezpośrednio. Nie jest wymagana konwersja do pośredniego typu opakowującego. Pełny zestaw akceptowanych typów danych wejściowych można znaleźć w przewodniku dotyczącym obrazów i przewodniku dotyczącym strumieni.

Problem 3: Wzorzec pętli ResultIterator nie ma bezpośredniego odpowiednika

Tesseract: Kod, który wykonuje iterację ResultIterator z iter.Begin(), iter.Next(PageIteratorLevel.Word) i iter.TryGetBoundingBox(), to standardowy wzorzec do ekstrakcji na poziomie słowa lub znaku. Ten wzorzec wymaga ręcznego śledzenia stanu iteratora i zmian poziomów.

Rozwiązanie: Zamień pętlę iteratora na LINQ nad result.Words, result.Pages lub odpowiednim poziomem kolekcji:

// Before: iterator loop
using var iter = page.GetIterator();
iter.Begin();
do
{
    if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
    {
        string text = iter.GetText(PageIteratorLevel.Word);
        // process text and bounds
    }
}
while (iter.Next(PageIteratorLevel.Word));

// After: enumerable collection
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    // word.Text, word.X, word.Y, word.Width, word.Height, word.Confidence
}

// Before: iterator loop
using var iter = page.GetIterator();
iter.Begin();
do
{
    if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
    {
        string text = iter.GetText(PageIteratorLevel.Word);
        // process text and bounds
    }
}
while (iter.Next(PageIteratorLevel.Word));

// After: enumerable collection
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    // word.Text, word.X, word.Y, word.Width, word.Height, word.Confidence
}

Dla dostępu na poziomie akapitu — co nie ma prostego odpowiednika w iteratorze Tesseract — użyj result.Pages[i].Paragraphs. W przewodniku po wynikach odczytu opisano wszystkie dostępne poziomy.

Problem 4: Kod biblioteki PDF musi zostać całkowicie usunięty

Tesseract: Każdy kod, który konwertuje strony PDF na obrazy przed przekazaniem ich do Tesseract — pętle PdfiumViewer document.Render(), wywołania PDFtoImage Conversion.ToImage(), wzorce Docnet.Core GetPageReader() lub wywołania procesów GhostScript — istnieje tylko po to, by obejść brak możliwości otwierania PDF przez Tesseract. Te klasy, pętle, wzorce plików tymczasowych i natywne wdrożenia binarne stanowią jedynie szkielet wokół rzeczywistych wymagań.

Rozwiązanie: Całkowicie usuń kod renderowania plików PDF. Zamień cały blok renderowania i OCR na input.LoadPdf(path):

// Before: ~50-150 lines of PdfiumViewer + Tesseract + temp file management
// After:
using var input = new OcrInput();
input.LoadPdf("document.pdf");
input.Deskew();
input.DeNoise();
var result = new IronTesseract().Read(input);

// Before: ~50-150 lines of PdfiumViewer + Tesseract + temp file management
// After:
using var input = new OcrInput();
input.LoadPdf("document.pdf");
input.Deskew();
input.DeNoise();
var result = new IronTesseract().Read(input);

Usuń odwołania do pakietów PdfiumViewer, PDFtoImage i Docnet.Core z .csproj. Usuń natywne wdrożenia binarne (pdfium.dll, pliki wykonywalne GhostScript) z skryptów budowania i Dockerfile. Przewodnik dotyczący plików PDF obejmuje wybór zakresu stron oraz pliki PDF chronione hasłem.

Problem 5: Wzorzec silnika przetwarzania równoległego na wątek

Tesseract: Standardowy wzorzec dla bezpiecznego równoległego OCR tworzy nowy TesseractEngine wewnątrz ciała Parallel.ForEach, ponieważ pojedynczy silnik nie jest bezpieczny dla wątków. Powoduje to załadowanie pełnego modelu językowego dla każdego wątku.

Rozwiązanie: Utwórz IronTesseract raz przed pętlą i odwołaj się do niego wewnątrz:

// Before: engine per thread, 40-100 MB per language model, times thread count
Parallel.ForEach(files, file =>
{
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img    = Pix.LoadFromFile(file);
    using var page   = engine.Process(img);
    results[file] = page.GetText();
});

// After: single engine, thread-safe, shared pool
var ocr = new IronTesseract();
Parallel.ForEach(files, file =>
{
    var result = ocr.Read(file);
    results[file] = result.Text;
});

// Before: engine per thread, 40-100 MB per language model, times thread count
Parallel.ForEach(files, file =>
{
    using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
    using var img    = Pix.LoadFromFile(file);
    using var page   = engine.Process(img);
    results[file] = page.GetText();
});

// After: single engine, thread-safe, shared pool
var ocr = new IronTesseract();
Parallel.ForEach(files, file =>
{
    var result = ocr.Read(file);
    results[file] = result.Text;
});

Zmiana dotycząca bezpieczeństwa wątkowego eliminuję również wzorzec usuwania using z wnętrza ciała pętli, co było konieczne, aby zapewnić, że każdy silnik na wątek był usunięty szybko.

Problem 6: Wyliczenie EngineMode nie ma bezpośredniego odwzorowania

Tesseract: EngineMode.Default, EngineMode.TesseractOnly i EngineMode.LstmOnly pojawiają się w konstruktorach TesseractEngine, aby wybrać, czy Tesseract używa silnika legacy, LSTM, czy obu. Owijka charlesw udostępnia te tryby, ponieważ Tesseract 4.x zachował oba silniki.

**Rozwiązanie:**IronOCR wykorzystuje wyłącznie silnik Tesseract 5 LSTM, który jest konfiguracją o wysokiej dokładności. Nie istnieje parametr EngineMode, ponieważ nie ma już silnika legacy, do którego można by powrócić. Usuń argument EngineMode podczas tłumaczenia wywołania konstruktora. Dla strojenia pomiędzy wydajnością a dokładnością użyj ocr.Configuration.PageSegmentationMode i zapoznaj się z przewodnikiem optymalizacji prędkości.

Lista kontrolna migracji Tesseract

Przed migracją

Sprawdź kod źródłowy pod kątem wszystkich odniesień do Tesseract i tessdata:

# Find all using directives for the Tesseract namespace
grep -rn "using Tesseract" --include="*.cs" .

# Find TesseractEngine constructors
grep -rn "TesseractEngine\|TessDataPath\|tessdata" --include="*.cs" .

# Find Pix object usage
grep -rn "Pix\." --include="*.cs" .

# Find ResultIterator usage
grep -rn "GetIterator\|ResultIterator\|PageIteratorLevel" --include="*.cs" .

# Find PDF rendering libraries added for Tesseract
grep -rn "PdfiumViewer\|PDFtoImage\|Docnet\|GhostScript" --include="*.cs" .

# Find tessdata references in project files
grep -rn "tessdata\|traineddata" --include="*.csproj" .

# Find tessdata references in Dockerfiles
grep -rn "tessdata\|TESSDATA_PREFIX\|libtesseract" Dockerfile* .

# Find all using directives for the Tesseract namespace
grep -rn "using Tesseract" --include="*.cs" .

# Find TesseractEngine constructors
grep -rn "TesseractEngine\|TessDataPath\|tessdata" --include="*.cs" .

# Find Pix object usage
grep -rn "Pix\." --include="*.cs" .

# Find ResultIterator usage
grep -rn "GetIterator\|ResultIterator\|PageIteratorLevel" --include="*.cs" .

# Find PDF rendering libraries added for Tesseract
grep -rn "PdfiumViewer\|PDFtoImage\|Docnet\|GhostScript" --include="*.cs" .

# Find tessdata references in project files
grep -rn "tessdata\|traineddata" --include="*.csproj" .

# Find tessdata references in Dockerfiles
grep -rn "tessdata\|TESSDATA_PREFIX\|libtesseract" Dockerfile* .

SHELL

Wyniki inwentaryzacji w celu oszacowania zakresu migracji:

Policz pliki za pomocą using Tesseract, aby określić, ile klas wymaga zmian.
Określ, która biblioteka do renderowania plików PDF jest używana (PdfiumViewer, PDFtoImage, Docnet.Core, GhostScript)
Zanotuj, jakie języki są referencjonowane w ciągach konstruktorów TesseractEngine, aby określić, które pakiety językowe NuGet IronOCR dodać.

Migracja kodu

Usuń referencję do pakietu NuGet Tesseract z wszystkich plików .csproj.
Usuń odniesienia NuGet do bibliotek renderowania PDF dodane wyłącznie w celu obsługi Tesseract (PdfiumViewer, PDFtoImage, Docnet.Core)
Zainstaluj pakiet NuGet IronOcr.
Zainstaluj wymagane pakiety językowe NuGet (IronOcr.Languages.French, etc.).
Dodaj IronOcr.License.LicenseKey = "YOUR-KEY"; na początku aplikacji.
Zamień using Tesseract; na using IronOcr; we wszystkich dotkniętych plikach.
Usuń stałe TessDataPath i wszystkie strażniki tessdata Directory.Exists / File.Exists.
Zamień new TesseractEngine(...) na new IronTesseract().
Zamień Pix.LoadFromFile(path) na input.LoadImage(path) w instancji OcrInput.
Zamień Pix.LoadFromMemory(bytes) na input.LoadImage(bytes).
Zamień engine.Process(img) na ocr.Read(input).
Zamień page.GetText() na result.Text.
Zamień page.GetMeanConfidence() na result.Confidence.
Zamień pętle ResultIterator na enumerację nad result.Words lub result.Pages[i].Paragraphs.
Zamień pętle renderowania PDF na input.LoadPdf(path) — usuń cały kod biblioteki renderowania.
Zamień ciągi języków "eng+fra+deu" na wywołania ocr.AddSecondaryLanguage(OcrLanguage.X).
Usuń folder tessdata i jego elementy build projektu <Content Include="...">.
Usuń kroki wdrażania natywnych plików binarnych ze skryptów kompilacji i plików Dockerfile (tessdata COPY, TESSDATA_PREFIX ENV, apt-get libtesseract-dev)

Po migracji

Sprawdź podstawowe wyodrębnianie tekstu na tych samych przykładowych obrazach, które były używane podczas tworzenia opakowania Tesseract
Sprawdź, czy wyniki pewności są rozsądne (70%+ dla dokumentów czystych, 85%+ dla skanów wysokiej jakości)
Przetestuj, czy wejście wielostronicowe TIFF generuje prawidłową liczbę stron w result.Pages.
Sprawdź, czy funkcja PDF input odczytuje zeskanowane pliki PDF bez konieczności korzystania z PdfiumViewer lub jakiejkolwiek biblioteki zewnętrznej
Przetestuj odczyt plików PDF chronionych hasłem za pomocą input.LoadPdf(path, Password: "...") w stosunku do znanego zaszyfrowanego pliku.
Upewnij się, że plik PDF z możliwością wyszukiwania otwiera się w programie Adobe Reader i obsługuje wyszukiwanie tekstowe
Przetestuj przetwarzanie równoległe: utwórz jedną instancję IronTesseract przed pętlą Parallel.ForEach i potwierdź brak wyjątków dotyczących bezpieczeństwa wątkowego.
Sprawdź, czy każdy pakiet językowy generuje poprawny wynik dla zestawu dokumentów w języku docelowym
Uruchom budowanie Docker bez COPY tessdata i apt-get libtesseract-dev — potwierdź, że kontener się uruchamia i przetwarza dokumenty.
Sprawdź, czy w opublikowanym katalogu wyjściowym nie ma folderu tessdata ani natywnych plików DLL
Sprawdź, czy po usunięciu referencji do natywnych binariów nie pojawia się żadne TesseractException lub System.DllNotFoundException w logach.

Kluczowe korzyści z migracji do IronOCR

Wdrożenie zmniejsza się do pojedynczego pakietu. Folder tessdata, biblioteki natywne specyficzne dla platformy (tesseract50.dll, leptonica-1.82.0.dll, libtesseract.so.5) i wszelkie natywne binaria renderowania PDF znikają z artefaktu wdrożenia. Dodanie nowego środowiska — kontenera Linux, funkcji AWS Lambda, komputera programisty z systemem macOS — nie wymaga żadnych czynności konfiguracyjnych specyficznych dla danej platformy. Przewodnik wdrożeniowy dla Docker i przewodnik wdrożeniowy dla systemu Linux potwierdzają ten proces: zainstaluj pakiet, dodaj klucz licencyjny, uruchom. Bez apt-get, bez COPY, bez zmiennych środowiskowych.

Dodawanie języków zajmuje sekundy, a nie minuty. Dodanie wsparcia OCR dla języka hiszpańskiego przechodzi od "pobrania spa.traineddata, umieszczenia w folderze tessdata, aktualizacji manifestu wdrożenia, weryfikacji ścieżki w konstruktorze silnika" do dotnet add package IronOcr.Languages.Spanish oraz ocr.AddSecondaryLanguage(OcrLanguage.Spanish). Te same dwa kroki działają na każdej platformie. Zespoły obsługujące ponad 10 języków — co jest powszechne w międzynarodowych procesach przetwarzania dokumentów — zauważają, że czas poświęcany na bieżącą konserwację skraca się z wielu godzin do kilku minut jednorazowej konfiguracji. Przejrzyj pełny katalog w indeksie języków.

Przepływy pracy z plikami PDF nie wymagają zewnętrznych bibliotek. Znika konieczność wdrażania i utrzymywania natywnych plików binarnych PdfiumViewer, zarządzania wersjami pdfium.dll dla środowisk 32- i 64-bitowych, zajmowania się kwestiami licencji AGPL z GhostScript oraz pisania pętli renderowania dla poszczególnych stron. input.LoadPdf() odczytuje zeskanowane PDF, cyfrowe PDF, mieszane PDF i PDF chronione hasłem natywnie. result.SaveAsSearchablePdf() produkuje wyszukiwalny wynik bez zaangażowania jakiejkolwiek zewnętrznej biblioteki. Cały proces — załadowanie zeskanowanego pliku PDF, wyprostowanie i usunięcie szumów, OCR, zapisanie wyników z możliwością wyszukiwania — zajmuje mniej niż 10 linii kodu. Zobacz wpis na blogu dotyczący plików PDF z funkcją wyszukiwania, aby zapoznać się z wzorcami potoków produkcyjnych.

Przetwarzanie wstępne jest wbudowane, nie tworzone przez Ciebie. Około 180 linii kodu ręcznego przetwarzania wstępnego — macierz kolorów w skali szarości, poprawa kontrastu z iteracją pikseli, usuwanie szumu filtrem medianowym, korekta pochylenia transformacją Hougha, skalowanie DPI — staje się sekwencją metod jednowierszowych: input.Deskew(), input.DeNoise(), input.Contrast(), input.Binarize(). W przypadku większości rzeczywistych dokumentów domyślny tryb odczytu stosuje inteligentne automatyczne przetwarzanie wstępne bez żadnych jawnych wywołań filtrów. Przewodnik po korekcji jakości obrazu oraz samouczek dotyczący filtrów obrazu obejmują pełny katalog filtrów.

Dokładność Tesseract 5 jest dostępna od razu. Owijka charlesw jest przypisana do Tesseract 4.1.1.IronOCR dostarcza zoptymalizowany silnik Tesseract 5 LSTM, który nie wymaga żadnych działań z Twojej strony. Zespoły, które odnotowały spadek dokładności w przypadku trudnych typów dokumentów — skanów o niskiej rozdzielczości, faksów, formularzy wypełnionych ręcznie — zyskują ulepszenia Tesseract 5 natychmiast po zmianie pakietu. Różnica w dokładności jest najbardziej zauważalna w dokumentach, w których rozpoznawanie LSTM przewyższa wydajnością starszy silnik, co dotyczy większości rzeczywistych zadań OCR.

Wsparcie komercyjne zastępuje pomoc techniczną społeczności. Charlesw wrapper to utrzymywany przez społeczność projekt open source bez gwarantowanych czasów odpowiedzi i bez umowy SLA.IronOCR zapewnia wsparcie e-mail, priorytetowe wsparcie na wyższych poziomach oraz komercyjnie utrzymywaną bazę kodu z regularnymi aktualizacjami zgodności z platformą .NET. Dla zespołów posiadających umowy SLA dotyczące przetwarzania dokumentów w ramach procesów produkcyjnych model wsparcia ma duże znaczenie. Strona produktu IronOCR oraz centrum dokumentacji zawierają pełen zestaw funkcji i opcji wdrożenia.

Zwróć uwagę: Ghostscript, PDFium, PDFSharp, Tesseract i iText są zarejestrowanymi znakami towarowymi ich odpowiednich właścicieli. Ta strona nie jest powiązana z, zaakceptowana ani sponsorowana przez Artifex Software, Chromium Project, Google, empira Software GmbH ani iText Group. Wszystkie nazwy produktów, loga i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.