IRONSOFTWAREHOME
IRONSUITEWszystkie 10 w cenie 2
EDYTOWANIE DOKUMENTÓW
ZDJĘCIA I ROZPOZNAWANIE
DZIAŁ SPRZEDAŻY
DARMOWE NARZĘDZIA
DOŁĄCZ DO NASZEJ SIECI EKSPERTÓW
FILMY

Migracja z Tesseract OCR Wrapper do IronOCR

Kannaopat Udonpant
Kannapat Udonpant
Updated: 1 sierpnia 2026

Ten przewodnik jest przeznaczony dla programistów .NET, którzy obecnie używają pakietu TesseractOCR NuGet i potrzebują jasnej, krok-po-kroku ścieżki do IronOCR. Obejmuje konkretne luki, które powodują migrację - niekompletny zasięg API i niespójne raportowanie błędów - oraz zawiera kod przed i po zmianach dla scenariuszy, w których luki te powodują największe problemy w aplikacjach produkcyjnych.

Dlaczego warto przejść z Tesseract OCR Wrapper

Pakiet TesseractOCR (opublikowany przez dewelopera społecznościowego Oachkatzlschwoaf) rozwiązuje podstawowy problem udostępnienia silnika Tesseract jako zarządzanego API .NET. W przypadku prac typu proof-of-concept jest to wystarczające. W przypadku systemów produkcyjnych, które wymagają niezawodnych sygnałów błędów, wielu formatów wyjściowych i kompletnej powierzchni API, wybory projektowe dotyczące opakowania stają się przeszkodami.

Niekompletna powierzchnia API. Owijka udostępnia funkcję wyodrębniania tekstu oraz zagregowaną wartość pewności typu float. W publicznym API brakuje danych na poziomie WORD, ramek ograniczających, przeglądania na poziomie wierszy oraz grupowania na poziomie akapitów. Aplikacje, które muszą wiedzieć, w którym miejscu strony pojawia się dana wartość - wyodrębnianie pól z faktur, procesy redagowania, analiza dokumentów - nie mają możliwości działania w ramach tej biblioteki. Dodanie drugiej biblioteki do analizowania hOCR z surowych danych Tesseracta wiąże się z pracą integracyjną, która z czasem się kumuluje.

Cicha awaria przy złym wejściu. Gdy silnik Tesseract napotka zdegradowany obraz, nieobsługiwany format lub wewnętrzny błąd przetwarzania, wrapper zwraca pusty ciąg z page.GetText() zamiast rzucać uchwytnym wyjątkiem zarządzanym. Kod wywołujący otrzymuje pusty wynik, który jest nie do odróżnienia od prawidłowej pustej strony. Zautomatyzowane potoki przetwarzające tysiące dokumentów dziennie mogą przez miesiące w sposób niezauważalny pomijać dane, zanim problem zostanie wykryty podczas audytu.

Brak możliwości tworzenia plików PDF z funkcją wyszukiwania. Program generuje zwykły tekst. Przekształcenie tego tekstu w plik PDF z możliwością wyszukiwania - co jest standardowym wymogiem zgodności w sektórach prawnym, opieki zdrowotnej i usług finansowych - wymaga oddzielnej biblioteki PDF, ręcznego montażu warstw tekstowych oraz obliczeń współrzędnych stron. Integracja ta obejmuje 150–300 wierszy i musi być utrzymywana niezależnie.

Brak natywnego wejścia PDF. Każda baza kodowa używająca opakowania, która przetwarza PDFy, zawiera warstwę rasteryzacji PDF-do-obrazu: typowo PdfiumViewer, Ghostscript lub PDFSharp wywołując API renderowania, aby przekształcić każdą stronę PDF w bitmapę przed przekazaniem go do silnika. Ta zależność dodaje złożoności, wprowadza krok utraty jakości z pośredniej rasteryzacji i wymaga odrębnej konfiguracji wdrażania.

Brak obsługi wielu formatów wejściowych. Główna ścieżka wejściowa wrapera to string z ścieżką do pliku przekazany do Pix.Image.LoadFromFile. Dane wejściowe oparte na strumieniach i tablicach bajtów - powszechne w aplikacjach ASP.NET odbierających przesłane pliki - wymagają najpierw zapisania bajtów do pliku tymczasowego, następnie przekazania tej ścieżki do silnika, a na koniec wyczyszczenia pliku tymczasowego. Ten schemat jest podatny na błędy i niepotrzebny.

Sztywność konfiguracji silnika. Owijka udostępnia podzbiór opcji konfiguracyjnych silnika Tesseract. Tryb segmentacji stron jest dostępny, ale konfiguracja normalizacji rozdzielczości, typu wyjściowego i parametrów rozpoznawania wymaga pracy na niższym poziomie abstrakcji niż ten, który zapewnia nakładka.

Podstawowy problem

Kontrakt błędów opakowania jest niezdefiniowany. Wywołanie, które wydaje się zakończone sukcesem, może w tle odrzucić wynik:

// TesseractOCR: no way to tell failure from "no text on this page"
using var engine = new Engine(@"./tessdata", Language.English);
using var img = Pix.Image.LoadFromFile(imagePath);
using var page = engine.Process(img);

var text = page.Text; // returns "" on engine failure — same as blank page
// Caller cannot distinguish OCR failure from legitimate empty result

IronOCR zgłasza błąd w przypadku awarii silnika i podaje numeryczny wskaźnik pewności dla każdego pomyślnego wyniku:

// IronOCR: failures throw, low-confidence results are detectable
var result = new IronTesseract().Read(imagePath);
// result.Confidence is 0-100; a score below 10 signals a processing problem
// An engine failure throws IronOcrException — never returns a silent empty string
Console.WriteLine($"Text: {result.Text}, Confidence: {result.Confidence}%");

##IronOCR a Tesseract OCR Wrapper: porównanie funkcji

Poniższa tabela przedstawia funkcje, które mają największe znaczenie dla aplikacji do przetwarzania dokumentów produkcyjnych.

FunkcjaTesseract OCR WrapperIronOCR
Pakiet NuGetTesseractOCR + ręczne tessdata + natywne binariówIronOcr (wszystkie zależności zebrane)
LicencjaApache 2.0 (bezpłatna)Komercyjny ($999–$2,399 wieczysta)
Wersja silnikaZależy od dołączonego natywnego pliku binarnegoZoptymalizowany Tesseract 5 (w pakiecie)
Wynik w postaci zwykłego tekstuTak (page.Text)Tak (result.Text)
Wynik w formacie PDF z możliwością wyszukiwaniaNieTak (result.SaveAsSearchablePdf())
eksport hOCRNieTak (result.SaveAsHocrFile())
Dane strukturalne dotyczące słów/wierszy/akapitówNieTak (z współrzędnymi ramki ograniczającej)
Wyniki pewności dla poszczególnych słówNieTak (word.Confidence)
Ogólna ocena pewnościTak (page.GetMeanConfidence(), liczba zmiennoprzecinkowa 0–1)Tak (result.Confidence, liczba zmiennoprzecinkowa 0–100)
Spójne obsługiwanie błędówNie (pusty ciąg znaków w przypadku niepowodzenia)Tak (wyjątki obsługiwane w całym tekście)
Natywne wprowadzanie plików PDFNieTak
Plik PDF chroniony hasłemNieTak
Wielostronicowy plik wejściowy w formacie TIFFOgraniczoneTak
Wejście strumieniowe i tablica bajtówBrak bezpośredniego wsparciaTak (input.LoadImage(stream), input.LoadImage(bytes))
Automatyczne prostowanieNieTak
Automatyczne usuwanie szumówNieTak
Automatyczne wzmocnienie kontrastuNieTak
BinaryzacjaNieTak
Odczytywanie BarCode podczas OCRNieTak (ocr.Configuration.ReadBarCodes = true)
OCR oparte na regionieBrak udostępnionego APITak (CropRectangle)
Bezpieczeństwo wątkówOgraniczonePełne (jedna instancja IronTesseract na wątek)
Wdrażanie wielopłatformoweWymaga natywnej konfiguracji plików binarnychWindows, Linux, macOS, Docker, Azure, AWS
Obsługa wersji .NETRóżni się w zależności od wersji opakowania.NET Framework 4.6.2+, .NET Core, .NET 5/6/7/8/9
Wsparcie komercyjneNoneTak (e-mail, priorytet na wyższych poziomach)

Szybki start: Migracja zTesseract OCR Wrapperdo IronOCR

Krok 1: Zastąp pakiet NuGet

Usuń istniejący pakiet:

dotnet remove package TesseractOCR
SHELL

Zainstaluj IronOCR z NuGet:

> dotnet add package IronOcr

Jeśli w projekcie używanych jest wiele języków, zainstaluj odpowiednie pakiety językowe:

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

Krok 2: Aktualizacja przestrzeni nazw

Zastąp stare odniesienia do przestrzeni nazw przestrzenią nazw IronOCR:

// Before (Tesseract OCR Wrapper)
using TesseractOCR;
using TesseractOCR.Enums;

// After (IronOCR)
using IronOcr;

Krok 3: Inicjalizacja licencji

Dodaj wywołanie klucza licencyjnego raz podczas uruchamiania aplikacji, przed wykonaniem jakichkolwiek operacji OCR:

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

Bezpłatny klucz próbny jest dostępny na stronie licencyjnej IronOCR i umożliwia korzystanie z pełnej funkcjonalności podczas okresu próbnego.

Przykłady migracji kodu

Zastąpienie cichych błędów niezawodną obsługą błędów

Błąd działania opakowania jest najczęstszym czynnikiem wywołującym migrację, z którym spotyka się większość zespołów. Zautomatyzowany proces działa przez tygodnie, a następnie audyt ujawnia, że pewien odsetek rekordów nie zawiera danych - nie dlatego, że dokumenty były puste, ale dlatego, że silnik po cichu zawiódł w określonych warunkach dotyczących obrazów.

Podejście oparte na Tesseract OCR Wrapper:

using TesseractOCR;

public class DocumentProcessor
{
    private readonly string _tessDataPath = @"./tessdata";

    public string ProcessDocument(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        // Empty string on engine failure — indistinguishable from blank page
        // Nie exception thrown, no confidence signal, no recovery path
        var text = page.Text;

        // Caller cannot tell if this is "" because:
        // - The document is genuinely blank
        // - The image format was not supported
        // - The engine encountered an internal error
        // - The tessdata was corrupted or version-mismatched
        return text;
    }
}

Podejście IronOCR:

using IronOcr;

public class DocumentProcessor
{
    public string ProcessDocument(string imagePath)
    {
        try
        {
            var result = new IronTesseract().Read(imagePath);

            // Confidence below threshold means the result is unreliable
            if (result.Confidence < 15)
            {
                // Route to human review queue — do not silently write empty data
                throw new InvalidOperationException(
                    $"OCR confidence too low ({result.Confidence:F1}%) for: {imagePath}");
            }

            return result.Text;
        }
        catch (IronOcrException ex)
        {
            // Engine failures are typed exceptions — never silent empty strings
            // Log and rethrow with context so the pipeline can flag the document
            throw new ApplicationException(
                $"OCR engine failure processing '{imagePath}': {ex.Message}", ex);
        }
    }
}

Każdy tryb awarii pojawia się jako wykrywalny, typowany wyjątek. Wyniki niskiej jakości ujawniają swój wynik zaufania, dzięki czemu kod wywołujący może zdecydować, czy ponowić próbę z przetwarzaniem wstępnym, skierować do ręcznej weryfikacji, czy odrzucić dane wejściowe. Brak utraty danych.

Aby uzyskać pełny opis API oceny pewności, zapoznaj się z przewodnikiem dotyczącym ocen pewności.

Rozszerzenie wyników z tekstu zwykłego na potok archiwizacji dokumentów

Częstym wymaganiem w zarządzaniu dokumentami jest konwersja zeskanowanych archiwów - papierowych umów, faktur, zapisów faksów - na pliki PDF z możliwością wyszukiwania, które systemy zarządzania dokumentami mogą indeksować. Oprogramowanie generuje zwykły tekst i nic więcej. Utworzenie pliku PDF z możliwością wyszukiwania na podstawie tego wyniku wymaga biblioteki PDF, ręcznego nakładania tekstu, obliczeń współrzędnych dla każdej strony oraz obsługi metryki czcionek.

Podejście oparte na Tesseract OCR Wrapper:

using TesseractOCR;
// Also requires: a PDF library (PDFsharp, iText, or similar)
// Also requires: a PDF rasterizer (PdfiumViewer or Ghostscript) to convert input PDFs to images

public class ArchivePipeline
{
    private readonly string _tessDataPath = @"./tessdata";

    public string ExtractText(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        return page.Text; // Plain text only — searchable PDF requires a separate pipeline
    }

    // To create a searchable PDF from this text, you would need:
    // 1. Load the original image as a PDF page background
    // 2. Map character positions back to image coordinates
    // 3. Overlay an invisible text layer using a PDF library
    // 4. Handle multi-page documents with per-page iteration
    // That is approximately 150-300 lines of additional code
}

Podejście IronOCR:

using IronOcr;

public class ArchivePipeline
{
    // Single method handles the full document archive pipeline
    public void ProcessArchive(string[] inputPaths, string outputDirectory)
    {
        var ocr = new IronTesseract();

        foreach (var inputPath in inputPaths)
        {
            var result = ocr.Read(inputPath);

            // Plain text for full-text search indexing
            var textPath = Path.Combine(outputDirectory,
                Path.GetFileNameWithoutExtension(inputPath) + ".txt");
            File.WriteAllText(textPath, result.Text);

            // Searchable PDF — invisible text layer aligned to original scan
            var pdfPath = Path.Combine(outputDirectory,
                Path.GetFileNameWithoutExtension(inputPath) + "-searchable.pdf");
            result.SaveAsSearchablePdf(pdfPath);
        }
    }

    // Input can be scanned image files or existing PDFs — same API
    public void ProcessScannedPdf(string scannedPdfPath, string outputPath)
    {
        var result = new IronTesseract().Read(scannedPdfPath);
        result.SaveAsSearchablePdf(outputPath);
    }
}

Ten sam Read() przyjmuje zarówno pliki obrazów, jak i dokumenty PDF. Wywołanie SaveAsSearchablePdf() produkuje standardowy, indeksowalny plik PDF z prawidłowo umieszczoną niewidoczną warstwą tekstową. Brak zależności od biblioteki PDF, brak obliczeń współrzędnych, brak montażu nakładek tekstowych.

Przewodnik dotyczący tworzenia plików PDF z funkcją wyszukiwania oraz przykładowy plik PDF z funkcją wyszukiwania obejmują scenariusze wielostronicowe i wsadowe.

Uproszczenie konfiguracji silnika do przetwarzania wsadowego

Wrapper wymaga nowej instancji Engine dla każdego wywołania OCR, a ta instancja przyjmuje ścieżkę filesystemu tessdata jako wymagany argument konstruktora. W scenariuszu przetwarzania wsadowego obejmującym tysiące dokumentów oznacza to rozwiązywanie i sprawdzanie poprawności ścieżki tessdata przy każdym utworzeniu instancji - oraz obciążenie związane z inicjalizacją silnika w każdym miejscu wywołania.

Podejście oparte na Tesseract OCR Wrapper:

using TesseractOCR;

public class BatchOcrService
{
    // tessdata path must be configured correctly in every environment
    private readonly string _tessDataPath;

    public BatchOcrService(string tessDataPath)
    {
        // Path validation deferred to runtime — no early error on misconfiguration
        _tessDataPath = tessDataPath;
    }

    public IEnumerable<string> ProcessBatch(IEnumerable<string> imagePaths)
    {
        var results = new List<string>();

        foreach (var path in imagePaths)
        {
            // New engine created per document — tessdata path re-resolved each time
            using var engine = new Engine(_tessDataPath, Language.English);
            using var img = Pix.Image.LoadFromFile(path);
            using var page = engine.Process(img);

            results.Add(page.Text);
        }

        return results;
    }
}

Podejście IronOCR:

using IronOcr;

public class BatchOcrService
{
    // One IronTesseract instance for the lifetime of the service
    // Thread-safe — can be registered as a singleton in DI
    private readonly IronTesseract _ocr;

    public BatchOcrService()
    {
        _ocr = new IronTesseract();
        // Optional: tune for batch throughput
        _ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
    }

    public IEnumerable<string> ProcessBatch(IEnumerable<string> imagePaths)
    {
        // Reuse the initialized engine — no tessdata path re-resolution per call
        return imagePaths.Select(path => _ocr.Read(path).Text).ToList();
    }

    // Parallel batch processing — IronTesseract is thread-safe with separate instances
    public IEnumerable<string> ProcessBatchParallel(string[] imagePaths)
    {
        var results = new string[imagePaths.Length];

        Parallel.For(0, imagePaths.Length, i =>
        {
            // Separate instance per thread — thread-safe by design
            var ocr = new IronTesseract();
            results[i] = ocr.Read(imagePaths[i]).Text;
        });

        return results;
    }
}

Inicjalizacja silnika wiąże się z obciążeniem podczas uruchamiania. Ponowne użycie instancji IronTesseract w kolejnych wywołaniach eliminuje ten narzut. W przypadku obciążeń równoległych stosowany jest wzorzec jednej instancji na wątek - każda instancja jest inicjowana niezależnie i można z niej bezpiecznie korzystać jednocześnie. Bez blokad, bez współdzielonego stanu.

Zobacz przykład wielowątkowości, aby zapoznać się z kompletną implementacją równoległego przetwarzania wsadowego.

Obsługa danych wejściowych w wielu formatach bez plików tymczasowych

Aplikacje ASP.NET odbierające przesłane pliki otrzymują dokument w postaci strumienia lub tablicy bajtów. Główną ścieżką wejściową opakowania jest ścieżka systemu plików - oznacza to, że aplikacja musi zapisać przesłane bajty do pliku tymczasowego, przekazać tę ścieżkę do silnika, a następnie usunąć plik tymczasowy. Ten schemat jest niestabilny i powoduje dodatkowe obciążenie operacji wejścia/wyjścia przy każdym żądaniu.

Podejście oparte na Tesseract OCR Wrapper:

using TesseractOCR;

public class UploadOcrController
{
    private readonly string _tessDataPath = @"./tessdata";

    public async Task<string> ProcessUpload(Stream uploadStream)
    {
        // Must write to temp file — no direct stream input path in the wrapper
        var tempPath = Path.GetTempFileName();
        try
        {
            using (var fileStream = File.Create(tempPath))
            {
                await uploadStream.CopyToAsync(fileStream);
            }

            using var engine = new Engine(_tessDataPath, Language.English);
            using var img = Pix.Image.LoadFromFile(tempPath); // file path required
            using var page = engine.Process(img);

            return page.Text;
        }
        finally
        {
            // Cleanup — if this throws, temp file leaks
            if (File.Exists(tempPath))
                File.Delete(tempPath);
        }
    }
}

Podejście IronOCR:

using IronOcr;

public class UploadOcrController
{
    public string ProcessUpload(Stream uploadStream)
    {
        // Direct stream input — no temporary file, no I/O overhead, no cleanup
        using var input = new OcrInput();
        input.LoadImage(uploadStream);
        return new IronTesseract().Read(input).Text;
    }

    public string ProcessUploadBytes(byte[] imageBytes)
    {
        // Byte array input — works directly from memory
        using var input = new OcrInput();
        input.LoadImage(imageBytes);
        return new IronTesseract().Read(input).Text;
    }

    public string ProcessMultiPageTiff(Stream tiffStream)
    {
        // Multi-frame TIFF — all frames processed in one call
        using var input = new OcrInput();
        input.LoadImageFrames(tiffStream);
        return new IronTesseract().Read(input).Text;
    }
}

OcrInput akceptuje strumienie, tablice bajtów, ścieżki do plików i wieloklatkowe TIFFy poprzez zunifikowane API ładowania. Nie ma plików tymczasowych, obciążenia wejścia/wyjścia ani logiki czyszczenia. Blok using na OcrInput poprawnie obsługuje zwalnianie zasobów.

Przewodnik po danych wejściowych strumieniowych oraz przewodnik po danych wejściowych obrazów obejmują wszystkie obsługiwane źródła danych wejściowych, w tym pliki mapowane w pamięci i strumienie sieciowe.

Pobieranie danych strukturalnych do analizy dokumentów

Wrapper zwraca cały dokument jako pojedynczy string z page.Text. Aplikacje, które muszą identyfikować konkretne pola - kwoty faktur, daty, pozycje - muszą analizować ten ciąg znaków za pomocą heurystyki lub wyrażeń regularnych bez żadnego kontekstu przestrzennego. Nie ma API umożliwiającego dostęp do poszczególnych słów wraz z ich pozycjami na stronie.

Podejście oparte na Tesseract OCR Wrapper:

using TesseractOCR;
using System.Text.RegularExpressions;

public class InvoiceFieldExtractor
{
    private readonly string _tessDataPath = @"./tessdata";

    public Dictionary<string, string> ExtractFields(string imagePath)
    {
        using var engine = new Engine(_tessDataPath, Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        var fullText = page.Text;

        // Must parse the full string — no spatial context available
        // Pattern matching is fragile across different invoice layouts
        var fields = new Dictionary<string, string>();

        var totalMatch = Regex.Match(fullText, @"Total[:\s]+\$?([\d,]+\.\d{2})");
        if (totalMatch.Success)
            fields["Total"] = totalMatch.Groups[1].Value;

        var dateMatch = Regex.Match(fullText, @"Date[:\s]+(\d{1,2}/\d{1,2}/\d{4})");
        if (dateMatch.Success)
            fields["Date"] = dateMatch.Groups[1].Value;

        return fields;
        // Nie spatial fallback when text patterns fail — the data is lost
    }
}

Podejście IronOCR:

using IronOcr;

public class InvoiceFieldExtractor
{
    public Dictionary<string, string> ExtractFields(string imagePath)
    {
        var result = new IronTesseract().Read(imagePath);
        var fields = new Dictionary<string, string>();

        // Traverse structured result — words carry position and confidence
        foreach (var page in result.Pages)
        {
            foreach (var paragraph in page.Paragraphs)
            {
                var paraText = paragraph.Text.Trim();

                // Spatial proximity: find words near known label positions
                if (paraText.StartsWith("Total", StringComparison.OrdinalIgnoreCase))
                {
                    fields["Total"] = paraText;
                    // paragraph.X, paragraph.Y give position for layout validation
                }

                if (paraText.StartsWith("Invoice Date", StringComparison.OrdinalIgnoreCase))
                {
                    fields["Date"] = paraText;
                }
            }
        }

        // Flag low-confidence extractions for review rather than silently accepting them
        var lowConfidenceWords = result.Pages
            .SelectMany(p => p.Paragraphs)
            .SelectMany(para => para.Words)
            .Where(w => w.Confidence < 50)
            .Select(w => w.Text)
            .ToList();

        if (lowConfidenceWords.Any())
            fields["_LowConfidenceWarning"] = string.Join(", ", lowConfidenceWords);

        return fields;
    }
}

Hierarchia result.Pages[].Paragraphs[].Words[] ujawnia pozycję (X, Y, Width, Height) i pewność dla każdego słowa. Logika ekstrakcji, która wcześniej opierała się na zawodnym parsowaniu ciągów znaków, może wykorzystywać bliskość przestrzenną - wiedząc, że wartość pojawia się po prawej stronie lub bezpośrednio pod znaną etykietą na stronie.

Przewodnik po wynikach odczytu dokumentuje pełną hierarchię wraz z przykładami kodu dla typowych wzorców ekstrakcji.

Odnośnik do dokumentacji APITesseract OCR Wrapperdo IronOCR

Tesseract OCR WrapperOdpowiednik IronOCR
new Engine(tessDataPath, Language.English)new IronTesseract() (nie jest potrzebna ścieżka)
new Engine(tessDataPath, "eng+fra")ocr.Language = OcrLanguage.English; ocr.AddSecondaryLanguage(OcrLanguage.French)
Pix.Image.LoadFromFile(imagePath)input.LoadImage(imagePath)
engine.Process(img)ocr.Read(input) lub ocr.Read(imagePath)
page.Textresult.Text
page.GetMeanConfidence() (liczba zmiennoprzecinkowa 0–1)result.Confidence (liczba zmiennoprzecinkowa 0–100)
Brak odpowiednika - dane wejściowe strumieniowe wymagają pliku tymczasowegoinput.LoadImage(stream)
Brak odpowiednika - wprowadzanie bajtów wymaga pliku tymczasowegoinput.LoadImage(byteArray)
Brak odpowiednika - format PDF nie jest obsługiwanyinput.LoadPdf(pdfPath)
Brak odpowiednika - format PDF nie jest obsługiwanyinput.LoadPdf(pdfPath, Password: "secret")
Brak odpowiednika - TIFF wielokadrowy ograniczonyinput.LoadImageFrames(tiffPath)
Brak odpowiednika - brak formatów wyjściowych poza tekstemresult.SaveAsSearchablePdf(outputPath)
Brak odpowiednika - brak wyniku hOCRresult.SaveAsHocrFile(outputPath)
Brak odpowiednika - brak danych strukturalnychresult.Pages[i].Paragraphs[j].Words[k]
Brak odpowiednika - brak słów koordynującychword.X, word.Y, word.Width, word.Height
Brak odpowiednika - brak pewności co do poszczególnych słówword.Confidence
Brak odpowiednika - brak przetwarzania wstępnegoinput.Deskew(), input.DeNoise(), input.Contrast()
Brak odpowiednika - brak wyboru regionuinput.LoadImage(path, new CropRectangle(x, y, w, h))
Brak odpowiednika - brak obsługi BARCODEocr.Configuration.ReadBarCodes = true; result.BarCodes
TesseractException (niespójne)IronOcrException (spójne, zawsze wyrzucane w przypadku awarii)

Pełna dokumentacja klas i metod znajduje się w dokumentacji API IronTesseract oraz dokumentacji API OcrResult.

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

Problem 1: Wyniki zawierające puste ciągi znaków znikają po migracji

Wrapper Tesseract OCR: Kod, który sprawdzał if (string.IsNullOrEmpty(result)) do wykrywania zarówno awarii, jak i pustych stron, będzie zachowywał się inaczej po migracji.IronOCR zgłasza błąd w przypadku niepowodzenia zamiast zwracać pusty wynik, więc sprawdzanie na obecność pustego ciągu znaków nie wykrywa już błędów silnika.

Rozwiązanie: Rozdziel te dwie kwestie. Użyj try/catch dla awarii silnika i sprawdź result.Confidence dla filtrowania jakości:

try
{
    var result = new IronTesseract().Read(imagePath);
    if (result.Confidence < 10)
    {
        // Genuinely unreadable or blank — route to review
        return string.Empty;
    }
    return result.Text;
}
catch (IronOcrException)
{
    // Engine failure — log and handle separately from blank pages
    return null; // or rethrow
}

Problem 2: Zmieniona skala pewności

Wrapper Tesseract OCR: page.GetMeanConfidence() zwraca float pomiędzy 0 a 1. Kod, który ustala progi na wartościach takich jak 0.7f, uruchomi się dla każdego wyniku IronOCR.

Rozwiązanie: result.Confidence w IronOCR to double wyrażone jako procent (0 do 100). Zaktualizuj porównania progów, mnożąc starą wartość przez 100:

// Before (TesseractOCR): if (confidence < 0.7f)
// After (IronOCR):
if (result.Confidence < 70)
{
    // Below 70% confidence
}

Problem 3: Zmieniony format ciągów językowych

Wrapper Tesseract OCR: Języki są określone jako string oddzielony + w konstruktorze Engine: "eng+fra+deu". Odpowiednie pliki .traineddata muszą istnieć w katalogu tessdata na tej dokładnej ścieżce.

Rozwiązanie: Zainstaluj pakiety językowe NuGet i użyj wyliczenia OcrLanguage. Usuń katalog tessdata z wdrożenia:

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

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

W przewodniku po wielu językach wymieniono wszystkie ponad 125 dostępnych pakietów językowych.

Problem 4: Brak konfiguracji ścieżki Tessdata

Wrapper Tesseract OCR: Konstruktor Engine wymaga ścieżki systemu plików tessdata jako pierwszego argumentu. Ta ścieżka jest zazwyczaj przechowywana w konfiguracji i wstrzykiwana w czasie wykonywania. Po migracji ten klucz konfiguracyjny nie jest używany.

Rozwiązanie: Usuń ścieżkę tessdata z plików konfiguracyjnych i skryptów wdrożeniowych. Usuń katalog tessdata z repozytorium i artefaktów wdrożeniowych. Usuń parametr ścieżki z wywołania konstruktora Engine - IronOCR automatycznie rozwiązuje dane językowe z zainstalowanych pakietów NuGet:

// Before: new Engine(configuration["TessDataPath"], Language.English)
// After:
var ocr = new IronTesseract(); // language resolved from NuGet package
ocr.Language = OcrLanguage.English;

Problem 5: Dane wejściowe w formacie PDF wymagają usunięcia warstwy rasteryzacji

Tesseract OCR Wrapper: Przetwarzanie plików PDF wymaga biblioteki do rasteryzacji (PdfiumViewer, Ghostscript lub podobnej) w celu konwersji każdej strony na mapę bitową przed przekazaniem jej do silnika. Ta biblioteka nie jest już potrzebna.

Rozwiązanie: Usuń bibliotekę rasteryzacji PDF i zastąp cały proces konwersji, a następnie OCR bezpośrednim wywołaniem IronOCR:

// Before: rasterize each PDF page to bitmap, OCR each bitmap, collect results
// After:
using var input = new OcrInput();
input.LoadPdf("document.pdf");
var result = new IronTesseract().Read(input);
Console.WriteLine(result.Text);

Przewodnik dotyczący plików PDF obejmuje wybór zakresu stron oraz pliki PDF chronione hasłem.

Problem 6: Brak konieczności tworzenia pliku tymczasowego dla wejścia strumieniowego

Tesseract OCR Wrapper: Przesłanie pliku do kontrolera ASP.NET i przeprowadzenie OCR przesłanego strumienia wymagało zapisania bajtów do pliku tymczasowego, przeprowadzenia OCR na podstawie ścieżki do pliku, a następnie usunięcia pliku tymczasowego. Ten schemat powoduje pozostawienie osieroconych plików tymczasowych, jeśli wywołanie OCR zakończy się niepowodzeniem.

Rozwiązanie: Ładuj bezpośrednio ze strumienia za pomocą OcrInput:

// Before: write to temp, OCR, delete temp
// After:
public async Task<string> OcrUpload(IFormFile file)
{
    using var stream = file.OpenReadStream();
    using var input = new OcrInput();
    input.LoadImage(stream);
    return new IronTesseract().Read(input).Text;
}

Brak plików tymczasowych, brak logiki czyszczenia, brak plików osieroconych w przypadku wyjątku.

Lista kontrolna migracji Tesseract OCR Wrapper

Przed migracją

Przed napisaniem nowego kodu sprawdź kod źródłowy pod kątem wszystkich zastosowań wrappera:

# Find all files using the TesseractOCR namespace
grep -r "using TesseractOCR" --include="*.cs" .

# Find Engine constructor calls — these carry the tessdata path
grep -rn "new Engine(" --include="*.cs" .

# Find tessdata path configuration references
grep -rn "tessdata" --include="*.cs" .
grep -rn "tessdata" --include="*.json" .
grep -rn "tessdata" --include="*.xml" .

# Find all page.Text and page.GetText() calls — the primary output pattern
grep -rn "page\.Text\|page\.GetText()" --include="*.cs" .

# Find GetMeanConfidence calls — confidence scale will change
grep -rn "GetMeanConfidence" --include="*.cs" .

# Find PDF rasterization libraries that can be removed after migration
grep -rn "PdfiumViewer\|Ghostscript\|PDFsharp" --include="*.cs" .
grep -rn "PdfiumViewer\|Ghostscript\|PdfSharp" --include="*.csproj" .
SHELL

Przed napisaniem jakiegokolwiek kodu należy udokumentować wyniki. Zwróć uwagę, ile miejsc wywołania korzysta ze ścieżki tessdata, ile z oceny pewności oraz czy któryś z kodów opiera się na zwracaniu pustych ciągów znaków w celu wykrywania błędów.

Migracja kodu

  1. Usuń pakiet TesseractOCR NuGet z pliku projektu.
  2. Zainstaluj IronOcr przez dotnet add package IronOcr.
  3. Zainstaluj pakiety językowe dla każdego języka pobranego wcześniej jako pliki .traineddata.
  4. Dodaj IronOcr.License.LicenseKey = "YOUR-KEY"; przy uruchomieniu aplikacji.
  5. Zastąp wszystkie dyrektywy using TesseractOCR; i using TesseractOCR.Enums; przez using IronOcr;.
  6. Zastąp każdą instancję new Engine(tessDataPath, language) przez new IronTesseract().
  7. Zamień Pix.Image.LoadFromFile(path) i engine.Process(img) z ocr.Read(path) lub wywołaniem opartym na OcrInput.
  8. Zamień page.Text i page.GetText() z result.Text.
  9. Zaktualizuj porównania progów pewności: pomnóż stary float przez 100 dla skali procentowej double.
  10. Zastąp ciągi języków oddzielane + przez ocr.Language i wywołania ocr.AddSecondaryLanguage().
  11. Zastąp wykrywanie awarii pustych ciągów przez try/catch IronOcrException.
  12. Zastąp wzorce plików tymczasowych dla wejścia strumieniowego przez input.LoadImage(stream).
  13. Usuń odniesienia do biblioteki rastryzacji PDF, gdzie IronOCR's input.LoadPdf() zastępuje krok rastryzacji.
  14. Usuń katalog tessdata z artefaktów wdrożeniowych i plików konfiguracyjnych.
  15. Zarejestruj IronTesseract jako singleton w kontenerze DI dla sekwencyjnych zadań; użyj jednej instancji na wątek dla obciążeń równoległych.

Po migracji

  • Sprawdź, czy wyniki OCR na wcześniej zatwierdzonych obrazach testowych dorównują lub przewyższają jakość wyników generowanych przez wrapper.
  • Zweryfikuj, że awarie silnika teraz wyrzucają IronOcrException zamiast zwracać puste ciągi.
  • Upewnij się, że wyniki pewności mieszczą się w przedziale 0–100 oraz że porównania progowe wykorzystują zaktualizowaną skalę.
  • Przetestuj dokumenty wielojęzyczne, aby sprawdzić, czy pakiety NuGet dla poszczególnych języków są poprawnie zainstalowane i rozpoznawane.
  • Przetestuj ścieżki strumienia i tablicy bajtów, aby upewnić się, że nie są tworzone żadne pliki tymczasowe.
  • Przetestuj bezpośrednio plik PDF (bez rasteryzacji) i sprawdź, czy liczba stron oraz treść tekstu są poprawne.
  • Przetestuj plik PDF z możliwością wyszukiwania w przeglądarce PDF i upewnij się, że wyszukiwanie tekstu zwraca wyniki zgodne z oryginalnym skanem.
  • Uruchom ścieżkę przetwarzania wsadowego i zweryfikuj przepustowość z ponownie używaną instancją IronTesseract.
  • Sprawdź, czy katalog tessdata został usunięty z wdrożenia i czy aplikacja uruchamia się poprawnie bez niego.
  • Przeprowadź test obciążenia na dowolnych punktach końcowych ASP.NET, które wykonują OCR, aby zweryfikować bezpieczeństwo wątków w instancjach na żądanie.

Kluczowe korzyści z migracji do IronOCR

Zdefiniowana umowa dotycząca błędów. Po migracji każda awaria OCR generuje wykrywalny, typowany wyjątek z sensownym komunikatem. Nie ma już cichego trybu awarii z pustym ciągiem znaków. Pipeline'y, które wcześniej wymagały zewnętrznej logiki walidacji jakości - sprawdzania rozmiarów plików, przeprowadzania analizy obrazów, porównywania liczby znaków - mogą teraz polegać na modelu wyjątków i wynikach pewności IronOCR.

Format wyjściowy bez dodatkowych bibliotek. Obiekt OcrResult, który wraca z każdego wywołania Read() obsługuje zwykły tekst, przeszukiwalny PDF i eksport hOCR bez dodatkowych pakietów. Generowanie plików PDF z możliwością wyszukiwania na potrzeby archiwów zgodności oraz eksport hOCR dla procesów zapewniania dostępności to teraz tylko dwie linijki kodu, a nie projekt integracji wielu bibliotek.

Dane strukturalne dla analizy dokumentów. Pełna hierarchia słów - strony, akapity, wiersze, słowa, znaki - wraz ze współrzędnymi ramki ograniczającej i poziomem pewności dla każdego słowa jest dostępna dla każdego obiektu wynikowego. Narzędzia do wyodrębniania faktur, redagowania i przetwarzania formularzy, które wcześniej analizowały płaskie ciągi znaków za pomocą niestabilnych wyrażeń regularnych, zyskują kontekst przestrzenny, dzięki czemu identyfikacja pól jest niezależna od układu. Strona poświęcona wynikom OCR obejmuje pełny model danych.

Natywne obsługiwanie plików PDF i wielu formatów wejściowych. Biblioteka rasteryzacji plików PDF i powiązana z nią konfiguracja znikają z wykresu zależności. Strumienie i tablice bajtów ładują się bezpośrednio do OcrInput bez plików tymczasowych. Pliki TIFF z wieloma ramkami przetwarzane w jednym wywołaniu. Kod obsługi danych wejściowych otaczający opakowanie - wykrywanie formatu, zarządzanie plikami tymczasowymi, logika czyszczenia - został zastąpiony ujednoliconym interfejsem API ładowania.

Wdrażanie bez konfiguracji środowiska. Katalog tessdata, sprawdzanie natywnej wersji binarnej oraz kroki wdrażania plików binarnych specyficzne dla platformy zostały usunięte.IronOCR zawiera swój silnik i dane językowe w pakiecie NuGet. Wdrożenie w Dockerze, systemie Linux, Azure lub AWS nie wymaga żadnej konfiguracji specyficznej dla środowiska poza jednowierszową zależnością biblioteki.

Wsparcie komercyjne i przewidywalne licencjonowanie. Wrapper jest utrzymywany przez społeczność i nie obejmuje umowy wsparcia.IronOCR zapewnia wsparcie e-mail, zespół ds. dokumentacji oraz regularne aktualizacje z gwarancją kompatybilności z Wersjami .NET. Model licencji wieczystej - zaczynający się od $999 dla poziomu Lite - oznacza brak niespodzianek związanych z rozliczaniem za strony i brak odnawiania subskrypcji, które blokują dostęp do nowych wersji .NET. Inwestycja w licencję zwraca się zazwyczaj już w pierwszej iteracji, która eliminuje prace integracyjne wymagane przez luki w wrapperze.

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.
Kannaopat Udonpant
Kannapat Udonpant
Inżynier oprogramowania

Powiązane artykuły

Key in blue circle

Uzyskaj natychmiast swój darmowy 30-dniowy Klucz Testowy.

Your trial license will be sent to your email address

Brak ograniczeń. 100% dostępności. Bez karty kredytowej.

bullet_checkedNie wymaga karty kredytowej ani tworzenia kontaBrak ograniczeń. 100% dostępności. Bez karty kredytowej.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Join Millions of Engineers who’ve tried IronOCR
Zarezerwuj swoje darmowe Demo na żywo
Booking Badge

Zaufane przez miliony inżynierów na całym świecie

Logotypy klientów Iron Software
Otrzymaj swoje Konsultacja Bez Zobowiązań
Twoje dane zawsze będą utrzymywane w tajemnicy.
  • Logo Aetna
  • Logo NASA
  • Logo GE
  • Logo Porsche
  • Logo USDA
  • Logo Qatar
Zaufane przez miliony inżynierów na całym świecie
Otrzymaj swój darmowy Klucz Próbny na 30 dni natychmiast.
Nie wymaga karty kredytowej ani tworzenia konta
Biblioteka C# NuGet dla plików PDF
Zainstaluj za pomocą NuGet

Wersja: 2026.10

PM > Install-Package IronOcr
nuget.org/packages/IronOcr/
  1. W Eksploratorze Rozwiązań, kliknij prawym przyciskiem Myszy na Odwołania, Zarządzaj pakietami NuGet
  2. Wybierz Przeglądaj i szukaj „IronOCR”
  3. Wybierz pakiet i zainstaluj
DLL PDF dla C#
Pobierz DLL

Wersja: 2026.10

lub pobierz Instalator Windows tutaj.

  1. Pobierz i rozpakuj IronOCR do lokalizacji, takiej jak ~/Libs w katalogu Solution
  2. W Eksploratorze rozwiązań Visual Studio kliknij prawym przyciskiem myszy Odwołania. Wybierz Przeglądaj, „IronOCR.dll”

Licencje od 999 USD