Jak debugować OCR w C#

Updated: 9 maja 2026

IronOCR umożliwia wykrycie niepowodzeń OCR u źródła, ocenę jakości rozpoznania na poziomie słów i znaków oraz monitorowanie długotrwałych zadań w czasie rzeczywistym. Wbudowane narzędzia takie jak logowanie diagnostyczne plików, hierarchia wyjątków typowanych, ocena pewności wyniku i zdarzenie OcrProgress wspierają te przepływy pracy w produkcyjnych pipeline'ach.

W niniejszym przewodniku omówiono praktyczne przykłady dla każdego z nich: włączanie rejestrowania diagnostycznego, obsługa wyjątków typowanych, sprawdzanie poprawności wyników za pomocą wskaźników pewności, monitorowanie postępu zadań w czasie rzeczywistym oraz izolowanie błędów w potokach przetwarzania wsadowego.

Szybki start: Włącz pełne logowanie diagnostyczne OCR

Ustaw LogFilePath i LoggingMode w klasie Installation przed pierwszym wywołaniem Read. Wystarczą dwie właściwości, aby zapisać w pliku dziennika informacje o inicjalizacji Tesseract, ładowaniu pakietu językowego oraz szczegółach przetwarzania.

1Install IronOCR with NuGet Package Manager
PM > Install-Package IronOcr
```
Install-Package IronOcr
```

2Skopiuj i uruchom ten fragment kodu.

IronOcr.Installation.LogFilePath = "ocr.log"; IronOcr.Installation.LoggingMode = IronOcr.Installation.LoggingModes.All;

IronOcr.Installation.LogFilePath = "ocr.log"; IronOcr.Installation.LoggingMode = IronOcr.Installation.LoggingModes.All;

3Wdrożenie do testowania w środowisku produkcyjnym

Rozpocznij używanie IronOCR w swoim projekcie już dziś z darmową wersją próbną

Minimalny proces (5 kroków)

Pobierz bibliotekę C# do debugowania OCR
Ustaw LogFilePath na ścieżkę do pliku z prawem do zapisu
Ustaw LoggingMode na All, aby uzyskać pełny zapis diagnostyczny
Uruchom operację OCR i odtworz problem
Sprawdź wygenerowany plik dziennika pod kątem ostrzeżeń silnika i szczegółów przetwarzania

Jak włączyć rejestrowanie diagnostyczne?

Klasa Installation udostępnia trzy kontrolki logowania. Ustaw to przed wywołaniem jakiejkolwiek metody Read.

using IronOcr;

// Write logs to a specific file
Installation.LogFilePath = "logs/ocr_diagnostics.log";

// Enable all logging channels: file + debug output
Installation.LoggingMode = Installation.LoggingModes.All;

// Or pipe logs into your existing ILogger pipeline
Installation.CustomLogger = myLoggerInstance;

using IronOcr;

// Write logs to a specific file
Installation.LogFilePath = "logs/ocr_diagnostics.log";

// Enable all logging channels: file + debug output
Installation.LoggingMode = Installation.LoggingModes.All;

// Or pipe logs into your existing ILogger pipeline
Installation.CustomLogger = myLoggerInstance;

Imports IronOcr

' Write logs to a specific file
Installation.LogFilePath = "logs/ocr_diagnostics.log"

' Enable all logging channels: file + debug output
Installation.LoggingMode = Installation.LoggingModes.All

' Or pipe logs into your existing ILogger pipeline
Installation.CustomLogger = myLoggerInstance

Imports IronOcr

' Write logs to a specific file
Installation.LogFilePath = "logs/ocr_diagnostics.log"

' Enable all logging channels: file + debug output
Installation.LoggingMode = Installation.LoggingModes.All

' Or pipe logs into your existing ILogger pipeline
Installation.CustomLogger = myLoggerInstance

LoggingMode przyjmuje wartości flag z enum LoggingModes:

Tabela 1: Opcje trybów logowania
Tryb	Wynik docelowy	Przykład zastosowania
`Brak`	Wyłączone	Produkcja z zewnętrznym monitoringiem
`Debugowanie`	Okno wyjściowe debugowania IDE	Lokalny rozwój
`Plik`	`LogFilePath`	Gromadzenie logów po stronie serwera
`Wszystkie`	Debug + Plik	Pełny zrzut diagnostyczny

Właściwość CustomLogger wspiera każdą implementację Microsoft.Extensions.Logging.ILogger, pozwalając kierować diagnostykę OCR do Serilog, NLog lub innych strukturalnych źródeł logowania w twoim pipeline. Użyj ClearLogFiles, aby usunąć zgromadzone dane logów między uruchomieniami.

Po skonfigurowaniu logowania następnym krokiem jest zrozumienie, jakie wyjątki może zgłaszać IronOCR i jak sobie z nimi radzić.

Jakie wyjątki generuje IronOCR?

IronOCR definiuje wyjątki typowane w ramach przestrzeni nazw IronOcr.Exceptions. Wykrywanie tych konkretnych błędów, zamiast stosowania ogólnego bloku przechwytującego, pozwala skierować każdy typ błędu do właściwej ścieżki naprawy.

Tabela 2: Odnośniki do wyjątków IronOCR
Wyjątek	Typowa przyczyna	Rozwiązanie
`IronOcrInputException`	Uszkodzony lub nieobsługiwany obraz/PDF	Zweryfikuj plik przed załadowaniem do `OcrInput`
`IronOcrProductException`	Błąd silnika wewnętrznego podczas wykonywania OCR	Włącz rejestrowanie, sprawdź wynik logu, zaktualizuj do najnowszej wersji NuGet
`IronOcrDictionaryException`	Brakuje lub jest uszkodzony plik językowy `.traineddata`	Ponownie zainstaluj pakiet językowy NuGet lub ustaw `LanguagePackDirectory`
`IronOcrNativeException`	Błąd interoperacyjności C++	Zainstaluj Visual C++ Redistributable; sprawdź wsparcie AVX
`IronOcrLicensingException`	Brakujący lub wygasły klucz licencyjny	Ustaw `LicenseKey` przed wywołaniem `Read`
`LanguagePackException`	Nie znaleziono pakietu językowego pod oczekiwaną ścieżką	Zweryfikuj `LanguagePackDirectory` lub ponownie zainstaluj pakiet językowy NuGet
`IronOcrAssemblyVersionMismatchException`	Niedopasowane wersje zestawów po częściowej aktualizacji	Wyczyść pamięć podręczną NuGet, przywróć pakiety, upewnij się, że wszystkie pakiety IronOCR są zgodne

Użyj poniższego bloku try-catch, aby obsłużyć każdy typ wyjątku osobno, stosując filtry wyjątków dla warunkowego logowania.

Dane wejściowe

Faktura jednostronicowa od IronOCR Solutions do Acme Corporation, załadowana za pomocą LoadPdf do OcrInput. Zawiera cztery pozycje na linii, podatek i łączną sumę — wystarczająco różnorodność tekstu, aby każdy obsługujący wyjątki miał realistyczne ćwiczenie.

invoice_scan.pdf: Faktura dostawcy (#INV-2024-7829) używana do demonstrowania każdego typowanego obsługującego wyjątków po kolei.

using IronOcr;
using IronOcr.Exceptions;

var ocr = new IronTesseract();

try
{
    using var input = new OcrInput();
    input.LoadPdf("invoice_scan.pdf");

    OcrResult result = ocr.Read(input);
    Console.WriteLine($"Text: {result.Text}");
    Console.WriteLine($"Confidence: {result.Confidence:P1}");
}
catch (IronOcrInputException ex)
{
    // File could not be loaded — corrupt, locked, or unsupported format
    Console.Error.WriteLine($"Input error: {ex.Message}");
}
catch (IronOcrDictionaryException ex)
{
    // Language pack missing — common in containerized deployments
    Console.Error.WriteLine($"Language pack error: {ex.Message}");
}
catch (IronOcrNativeException ex) when (ex.Message.Contains("AVX"))
{
    // CPU does not support AVX instructions
    Console.Error.WriteLine($"Hardware incompatibility: {ex.Message}");
}
catch (IronOcrLicensingException)
{
    Console.Error.WriteLine("License key is missing or invalid.");
}
catch (IronOcrProductException ex)
{
    // Catch-all for other IronOCR engine errors
    Console.Error.WriteLine($"OCR engine error: {ex.Message}");
    Console.Error.WriteLine($"Stack trace: {ex.StackTrace}");
}

using IronOcr;
using IronOcr.Exceptions;

var ocr = new IronTesseract();

try
{
    using var input = new OcrInput();
    input.LoadPdf("invoice_scan.pdf");

    OcrResult result = ocr.Read(input);
    Console.WriteLine($"Text: {result.Text}");
    Console.WriteLine($"Confidence: {result.Confidence:P1}");
}
catch (IronOcrInputException ex)
{
    // File could not be loaded — corrupt, locked, or unsupported format
    Console.Error.WriteLine($"Input error: {ex.Message}");
}
catch (IronOcrDictionaryException ex)
{
    // Language pack missing — common in containerized deployments
    Console.Error.WriteLine($"Language pack error: {ex.Message}");
}
catch (IronOcrNativeException ex) when (ex.Message.Contains("AVX"))
{
    // CPU does not support AVX instructions
    Console.Error.WriteLine($"Hardware incompatibility: {ex.Message}");
}
catch (IronOcrLicensingException)
{
    Console.Error.WriteLine("License key is missing or invalid.");
}
catch (IronOcrProductException ex)
{
    // Catch-all for other IronOCR engine errors
    Console.Error.WriteLine($"OCR engine error: {ex.Message}");
    Console.Error.WriteLine($"Stack trace: {ex.StackTrace}");
}

Imports IronOcr
Imports IronOcr.Exceptions

Dim ocr = New IronTesseract()

Try
    Using input = New OcrInput()
        input.LoadPdf("invoice_scan.pdf")

        Dim result As OcrResult = ocr.Read(input)
        Console.WriteLine($"Text: {result.Text}")
        Console.WriteLine($"Confidence: {result.Confidence:P1}")
    End Using
Catch ex As IronOcrInputException
    ' File could not be loaded — corrupt, locked, or unsupported format
    Console.Error.WriteLine($"Input error: {ex.Message}")
Catch ex As IronOcrDictionaryException
    ' Language pack missing — common in containerized deployments
    Console.Error.WriteLine($"Language pack error: {ex.Message}")
Catch ex As IronOcrNativeException When ex.Message.Contains("AVX")
    ' CPU does not support AVX instructions
    Console.Error.WriteLine($"Hardware incompatibility: {ex.Message}")
Catch ex As IronOcrLicensingException
    Console.Error.WriteLine("License key is missing or invalid.")
Catch ex As IronOcrProductException
    ' Catch-all for other IronOCR engine errors
    Console.Error.WriteLine($"OCR engine error: {ex.Message}")
    Console.Error.WriteLine($"Stack trace: {ex.StackTrace}")
End Try

Imports IronOcr
Imports IronOcr.Exceptions

Dim ocr = New IronTesseract()

Try
    Using input = New OcrInput()
        input.LoadPdf("invoice_scan.pdf")

        Dim result As OcrResult = ocr.Read(input)
        Console.WriteLine($"Text: {result.Text}")
        Console.WriteLine($"Confidence: {result.Confidence:P1}")
    End Using
Catch ex As IronOcrInputException
    ' File could not be loaded — corrupt, locked, or unsupported format
    Console.Error.WriteLine($"Input error: {ex.Message}")
Catch ex As IronOcrDictionaryException
    ' Language pack missing — common in containerized deployments
    Console.Error.WriteLine($"Language pack error: {ex.Message}")
Catch ex As IronOcrNativeException When ex.Message.Contains("AVX")
    ' CPU does not support AVX instructions
    Console.Error.WriteLine($"Hardware incompatibility: {ex.Message}")
Catch ex As IronOcrLicensingException
    Console.Error.WriteLine("License key is missing or invalid.")
Catch ex As IronOcrProductException
    ' Catch-all for other IronOCR engine errors
    Console.Error.WriteLine($"OCR engine error: {ex.Message}")
    Console.Error.WriteLine($"Stack trace: {ex.StackTrace}")
End Try

Wynik

Wynik końcowy

Faktura wczytuje się czysto, a silnik zwraca liczbę znaków razem z wynikiem zaufania.

Wyjście terminala pokazujące udane odczytanie OCR invoice_scan.pdf z liczbą znaków i wynikiem zaufania

Niepomyślne wyjście

Wyjście terminala pokazujące wyjątek rzucony podczas ładowania brakującego pliku PDF

Uporządkuj bloki catch od najbardziej specyficznego do najbardziej ogólnego. Klauzula when na IronOcrNativeException filtruje awarie związane z AVX bez łapania niepowiązanych błędów natywnych. Każdy obsługujący loguje komunikat o wyjątku; blok catch-all również przechwytuje ślad stosu do analizy post-mortem.

Złapanie właściwego wyjątku powie ci, że coś poszło nie tak, ale nie jak dobrze silnik działał, gdy się udało. Do tego użyj wyników zaufania.

Jak zweryfikować wynik OCR za pomocą wyników zaufania?

Każdy OcrResult udostępnia właściwość Confidence, wartość między 0 a 1 przedstawiającą statystyczną pewność silnika średnio w odniesieniu do wszystkich rozpoznanych znaków. Możesz uzyskać do tego dostęp na każdym poziomie hierarchii wyników: dokument, strona, akapit, słowo i znak.

Użyj wzorca bramkowanego progu, aby zapobiec propagowaniu się wyników niskiej jakości w dół strumienia.

Dane wejściowe

Paragon z pozycjonowymi liniami, rabatami, sumami i kodem kreskowym, załadowany za pomocą LoadImage. Jego wąska szerokość, monospace font i błądy druk czynią go praktycznym stresstestem dla progów zaufania dla każdego słowa.

Przykładowy termiczny paragon z FoodMart z pokazaniem zakupów z podziałem pozycji, sum i punktów nagrody używany jako wejście OCR

receipt.png: Skany paragonów termicznych używane do demonstrowania walidacji pewności progowej i szczegółowego przełamania dokładności na słowo dla obrazu paragonu.

using IronOcr;

var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadImage("receipt.png");

OcrResult result = ocr.Read(input);
double confidence = result.Confidence;

Console.WriteLine($"Overall confidence: {confidence:P1}");

// Threshold-gated decision
if (confidence >= 0.90)
{
    Console.WriteLine("ACCEPT — high confidence, processing result.");
    ProcessResult(result.Text);
}
else if (confidence >= 0.70)
{
    Console.WriteLine("FLAG — moderate confidence, queuing for review.");
    QueueForReview(result.Text, confidence);
}
else
{
    Console.WriteLine("REJECT — low confidence, logging for investigation.");
    LogRejection("receipt.png", confidence);
}

// Drill into per-page and per-word confidence for diagnostics
foreach (var page in result.Pages)
{
    Console.WriteLine($"  Page {page.PageNumber}: {page.Confidence:P1}");

    var lowConfidenceWords = page.Words
        .Where(w => w.Confidence < 0.70)
        .ToList();

    foreach (var word in lowConfidenceWords)
    {
        Console.WriteLine($"    Low-confidence word: \"{word.Text}\" ({word.Confidence:P1})");
    }
}

using IronOcr;

var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadImage("receipt.png");

OcrResult result = ocr.Read(input);
double confidence = result.Confidence;

Console.WriteLine($"Overall confidence: {confidence:P1}");

// Threshold-gated decision
if (confidence >= 0.90)
{
    Console.WriteLine("ACCEPT — high confidence, processing result.");
    ProcessResult(result.Text);
}
else if (confidence >= 0.70)
{
    Console.WriteLine("FLAG — moderate confidence, queuing for review.");
    QueueForReview(result.Text, confidence);
}
else
{
    Console.WriteLine("REJECT — low confidence, logging for investigation.");
    LogRejection("receipt.png", confidence);
}

// Drill into per-page and per-word confidence for diagnostics
foreach (var page in result.Pages)
{
    Console.WriteLine($"  Page {page.PageNumber}: {page.Confidence:P1}");

    var lowConfidenceWords = page.Words
        .Where(w => w.Confidence < 0.70)
        .ToList();

    foreach (var word in lowConfidenceWords)
    {
        Console.WriteLine($"    Low-confidence word: \"{word.Text}\" ({word.Confidence:P1})");
    }
}

Imports IronOcr

Dim ocr As New IronTesseract()
Using input As New OcrInput()
    input.LoadImage("receipt.png")

    Dim result As OcrResult = ocr.Read(input)
    Dim confidence As Double = result.Confidence

    Console.WriteLine($"Overall confidence: {confidence:P1}")

    ' Threshold-gated decision
    If confidence >= 0.9 Then
        Console.WriteLine("ACCEPT — high confidence, processing result.")
        ProcessResult(result.Text)
    ElseIf confidence >= 0.7 Then
        Console.WriteLine("FLAG — moderate confidence, queuing for review.")
        QueueForReview(result.Text, confidence)
    Else
        Console.WriteLine("REJECT — low confidence, logging for investigation.")
        LogRejection("receipt.png", confidence)
    End If

    ' Drill into per-page and per-word confidence for diagnostics
    For Each page In result.Pages
        Console.WriteLine($"  Page {page.PageNumber}: {page.Confidence:P1}")

        Dim lowConfidenceWords = page.Words _
            .Where(Function(w) w.Confidence < 0.7) _
            .ToList()

        For Each word In lowConfidenceWords
            Console.WriteLine($"    Low-confidence word: ""{word.Text}"" ({word.Confidence:P1})")
        Next
    Next
End Using

Imports IronOcr

Dim ocr As New IronTesseract()
Using input As New OcrInput()
    input.LoadImage("receipt.png")

    Dim result As OcrResult = ocr.Read(input)
    Dim confidence As Double = result.Confidence

    Console.WriteLine($"Overall confidence: {confidence:P1}")

    ' Threshold-gated decision
    If confidence >= 0.9 Then
        Console.WriteLine("ACCEPT — high confidence, processing result.")
        ProcessResult(result.Text)
    ElseIf confidence >= 0.7 Then
        Console.WriteLine("FLAG — moderate confidence, queuing for review.")
        QueueForReview(result.Text, confidence)
    Else
        Console.WriteLine("REJECT — low confidence, logging for investigation.")
        LogRejection("receipt.png", confidence)
    End If

    ' Drill into per-page and per-word confidence for diagnostics
    For Each page In result.Pages
        Console.WriteLine($"  Page {page.PageNumber}: {page.Confidence:P1}")

        Dim lowConfidenceWords = page.Words _
            .Where(Function(w) w.Confidence < 0.7) _
            .ToList()

        For Each word In lowConfidenceWords
            Console.WriteLine($"    Low-confidence word: ""{word.Text}"" ({word.Confidence:P1})")
        Next
    Next
End Using

Wynik

Ten wzorzec jest niezbędny w liniach, gdzie OCR wchodzi do wprowadzania danych, przetwarzania faktur lub przepływów pracy zgodności. Dogłębna analiza dla każdego słowa identyfikuje dokładnie, które obszary źródłowego obrazu powodowały degradację; możesz potem zastosować filtry jakości obrazu lub korekcje orientacji i ponownie przetworzyć. Aby uzyskać głębsze spojrzenie na wyniki zaufania, zobacz poziomy zaufania how-to.

Dla zadań długotrwałych, sam wynik zaufania nie wystarcza. Musisz także wiedzieć, czy silnik nadal przejawia postęp, i tu zdarzenie OcrProgress wchodzi w grę.

Jak monitorować postęp OCR w czasie rzeczywistym?

Dla dokumentów wielostronicowych zdarzenie OcrProgress na IronTesseract uruchamia się po ukończeniu każdej strony. Obiekt OcrProgressEventArgs udostępnia procent postępu, czas trwania, całkowitą liczbę stron i ukończone strony. Przykład używa tego trzystronicowego raportu kwartalnego jako wejścia: strukturalnego dokumentu biznesowego obejmującego sprawozdanie z zarządzania, rozbicie przychodów i metryki operacyjne.

Dane wejściowe

Trzystronicowy raport finansowy za pierwszy kwartał 2024 załadowany poprzez LoadPdf. Strona pierwsza obejmuje sprawozdanie z zarządzania z metrykami KPI, strona druga zawiera tabele przychodów według linii produktowej i regionu, a strona trzecia obejmuje wolumeny przetwarzania operacyjnego — każdy typ strony wytworzy różne czasy realizacji, które można zaobserwować w wywołaniach zwrotnych postępu.

quarterly_report.pdf: Trzystronicowy raport finansowy Q1 2024 (sprawozdanie z zarządzania, rozbicie przychodów, metryki operacyjne) używane do demonstrowania wywołań zwrotnych OcrProgress w czasie rzeczywistym na stronę.

using IronOcr;

var ocr = new IronTesseract();

ocr.OcrProgress += (sender, e) =>
{
    Console.WriteLine(
        $"[OCR] {e.ProgressPercent}% complete | " +
        $"Page {e.PagesComplete}/{e.TotalPages} | " +
        $"Elapsed: {e.Duration.TotalSeconds:F1}s"
    );
};

using var input = new OcrInput();
input.LoadPdf("quarterly_report.pdf");

OcrResult result = ocr.Read(input);
Console.WriteLine($"Finished in {result.Pages.Count()} pages, confidence: {result.Confidence:P1}");

using IronOcr;

var ocr = new IronTesseract();

ocr.OcrProgress += (sender, e) =>
{
    Console.WriteLine(
        $"[OCR] {e.ProgressPercent}% complete | " +
        $"Page {e.PagesComplete}/{e.TotalPages} | " +
        $"Elapsed: {e.Duration.TotalSeconds:F1}s"
    );
};

using var input = new OcrInput();
input.LoadPdf("quarterly_report.pdf");

OcrResult result = ocr.Read(input);
Console.WriteLine($"Finished in {result.Pages.Count()} pages, confidence: {result.Confidence:P1}");

Imports IronOcr

Dim ocr As New IronTesseract()

AddHandler ocr.OcrProgress, Sub(sender, e)
    Console.WriteLine($"[OCR] {e.ProgressPercent}% complete | " &
                      $"Page {e.PagesComplete}/{e.TotalPages} | " &
                      $"Elapsed: {e.Duration.TotalSeconds:F1}s")
End Sub

Using input As New OcrInput()
    input.LoadPdf("quarterly_report.pdf")

    Dim result As OcrResult = ocr.Read(input)
    Console.WriteLine($"Finished in {result.Pages.Count()} pages, confidence: {result.Confidence:P1}")
End Using

Imports IronOcr

Dim ocr As New IronTesseract()

AddHandler ocr.OcrProgress, Sub(sender, e)
    Console.WriteLine($"[OCR] {e.ProgressPercent}% complete | " &
                      $"Page {e.PagesComplete}/{e.TotalPages} | " &
                      $"Elapsed: {e.Duration.TotalSeconds:F1}s")
End Sub

Using input As New OcrInput()
    input.LoadPdf("quarterly_report.pdf")

    Dim result As OcrResult = ocr.Read(input)
    Console.WriteLine($"Finished in {result.Pages.Count()} pages, confidence: {result.Confidence:P1}")
End Using

Wynik

Wyjście terminala pokazujące wywołania zwrotne wydarzeń OcrProgress na stronę z procentem ukończenia i upływem czasu dla trzystronicowego PDF

Podłącz to wydarzenie do swojej infrastruktury logującej, aby śledzić czas trwania zadania OCR i wykrywać zacięcia. Jeśli czas upływu przekroczy próg bez postępu procentu postępu, linia może oznaczyć zadanie do zbadania. To jest szczególnie przydatne dla przetwarzania wsadowego PDF, gdzie jedna błędna strona może zablokować całe zadanie.

Monitorowanie postępu pokazuje stan wykonania, ale błąd na poziomie pliku nadal może zatrzymać całą partię, jeśli nie jest izolowany.

Jak obsługiwać błędy w przepływach wsadowych OCR?

W produkcji, jedna awaria pliku nie powinna zatrzymywać całej partii. Izoluj błędy dla każdego pliku, loguj awarie z kontekstem i twórz raport podsumowujący na końcu. Przykład przetwarza katalog dokumentów skanowania zawierający fakturę, zamówienie zakupu, umowę serwisową oraz jeden świadomie uszkodzony plik w celu wywołania ścieżki błędów. Poniżej pokazano reprezentatywną próbkę:

Dane wejściowe

Folder z plikami PDF przekazany do Directory.GetFiles - faktura, zlecenie zakupu, umowa serwisowa i jeden celowo uszkodzony plik. Dwa reprezentatywne próby poniżej pokazują różnorodność dokumentów, które przetwarza pipeline podczas jednego uruchomienia.

batch-scan-01.pdf: Faktura dla Bright Horizon Ltd. (INV-2024-001) — udane przejście OCR.

batch-scan-02.pdf: Zamówienie zakupu dla TechSupply Inc. (PO-2024-042) — drugi typ dokumentu w tym samym przebiegu.

using IronOcr;
using IronOcr.Exceptions;

var ocr = new IronTesseract();
Installation.LogFilePath = "batch_debug.log";
Installation.LoggingMode = Installation.LoggingModes.File;

string[] files = Directory.GetFiles("scans/", "*.pdf");
int succeeded = 0, failed = 0;
double totalConfidence = 0;
var failures = new List<(string File, string Error)>();

foreach (string file in files)
{
    try
    {
        using var input = new OcrInput();
        input.LoadPdf(file);

        OcrResult result = ocr.Read(input);
        totalConfidence += result.Confidence;
        succeeded++;

        Console.WriteLine($"OK: {Path.GetFileName(file)} — {result.Confidence:P1}");
    }
    catch (IronOcrInputException ex)
    {
        failed++;
        failures.Add((file, $"Input error: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}");
    }
    catch (IronOcrProductException ex)
    {
        failed++;
        failures.Add((file, $"Engine error: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}");
    }
    catch (Exception ex)
    {
        failed++;
        failures.Add((file, $"Unexpected: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.GetType().Name}: {ex.Message}");
    }
}

// Summary report
Console.WriteLine($"\n--- Batch Summary ---");
Console.WriteLine($"Total: {files.Length} | Passed: {succeeded} | Failed: {failed}");
if (succeeded > 0)
    Console.WriteLine($"Average confidence: {totalConfidence / succeeded:P1}");

foreach (var (f, err) in failures)
    Console.WriteLine($"  {Path.GetFileName(f)}: {err}");

using IronOcr;
using IronOcr.Exceptions;

var ocr = new IronTesseract();
Installation.LogFilePath = "batch_debug.log";
Installation.LoggingMode = Installation.LoggingModes.File;

string[] files = Directory.GetFiles("scans/", "*.pdf");
int succeeded = 0, failed = 0;
double totalConfidence = 0;
var failures = new List<(string File, string Error)>();

foreach (string file in files)
{
    try
    {
        using var input = new OcrInput();
        input.LoadPdf(file);

        OcrResult result = ocr.Read(input);
        totalConfidence += result.Confidence;
        succeeded++;

        Console.WriteLine($"OK: {Path.GetFileName(file)} — {result.Confidence:P1}");
    }
    catch (IronOcrInputException ex)
    {
        failed++;
        failures.Add((file, $"Input error: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}");
    }
    catch (IronOcrProductException ex)
    {
        failed++;
        failures.Add((file, $"Engine error: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}");
    }
    catch (Exception ex)
    {
        failed++;
        failures.Add((file, $"Unexpected: {ex.Message}"));
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.GetType().Name}: {ex.Message}");
    }
}

// Summary report
Console.WriteLine($"\n--- Batch Summary ---");
Console.WriteLine($"Total: {files.Length} | Passed: {succeeded} | Failed: {failed}");
if (succeeded > 0)
    Console.WriteLine($"Average confidence: {totalConfidence / succeeded:P1}");

foreach (var (f, err) in failures)
    Console.WriteLine($"  {Path.GetFileName(f)}: {err}");

Imports IronOcr
Imports IronOcr.Exceptions

Dim ocr As New IronTesseract()
Installation.LogFilePath = "batch_debug.log"
Installation.LoggingMode = Installation.LoggingModes.File

Dim files As String() = Directory.GetFiles("scans/", "*.pdf")
Dim succeeded As Integer = 0, failed As Integer = 0
Dim totalConfidence As Double = 0
Dim failures As New List(Of (File As String, Error As String))()

For Each file As String In files
    Try
        Using input As New OcrInput()
            input.LoadPdf(file)

            Dim result As OcrResult = ocr.Read(input)
            totalConfidence += result.Confidence
            succeeded += 1

            Console.WriteLine($"OK: {Path.GetFileName(file)} — {result.Confidence:P1}")
        End Using
    Catch ex As IronOcrInputException
        failed += 1
        failures.Add((file, $"Input error: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}")
    Catch ex As IronOcrProductException
        failed += 1
        failures.Add((file, $"Engine error: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}")
    Catch ex As Exception
        failed += 1
        failures.Add((file, $"Unexpected: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.GetType().Name}: {ex.Message}")
    End Try
Next

' Summary report
Console.WriteLine(vbCrLf & "--- Batch Summary ---")
Console.WriteLine($"Total: {files.Length} | Passed: {succeeded} | Failed: {failed}")
If succeeded > 0 Then
    Console.WriteLine($"Average confidence: {totalConfidence / succeeded:P1}")
End If

For Each failure In failures
    Console.WriteLine($"  {Path.GetFileName(failure.File)}: {failure.Error}")
Next

Imports IronOcr
Imports IronOcr.Exceptions

Dim ocr As New IronTesseract()
Installation.LogFilePath = "batch_debug.log"
Installation.LoggingMode = Installation.LoggingModes.File

Dim files As String() = Directory.GetFiles("scans/", "*.pdf")
Dim succeeded As Integer = 0, failed As Integer = 0
Dim totalConfidence As Double = 0
Dim failures As New List(Of (File As String, Error As String))()

For Each file As String In files
    Try
        Using input As New OcrInput()
            input.LoadPdf(file)

            Dim result As OcrResult = ocr.Read(input)
            totalConfidence += result.Confidence
            succeeded += 1

            Console.WriteLine($"OK: {Path.GetFileName(file)} — {result.Confidence:P1}")
        End Using
    Catch ex As IronOcrInputException
        failed += 1
        failures.Add((file, $"Input error: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}")
    Catch ex As IronOcrProductException
        failed += 1
        failures.Add((file, $"Engine error: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.Message}")
    Catch ex As Exception
        failed += 1
        failures.Add((file, $"Unexpected: {ex.Message}"))
        Console.Error.WriteLine($"FAIL: {Path.GetFileName(file)} — {ex.GetType().Name}: {ex.Message}")
    End Try
Next

' Summary report
Console.WriteLine(vbCrLf & "--- Batch Summary ---")
Console.WriteLine($"Total: {files.Length} | Passed: {succeeded} | Failed: {failed}")
If succeeded > 0 Then
    Console.WriteLine($"Average confidence: {totalConfidence / succeeded:P1}")
End If

For Each failure In failures
    Console.WriteLine($"  {Path.GetFileName(failure.File)}: {failure.Error}")
Next

Wynik

Zewnętrzny blok catch obsługuje nieprzewidziane błędy, w tym limity czasu sieci na współdzielonej pamięci, problemy z uprawnieniami lub stany brak pamięci na dużych TIFFach. Każda awaria rejestruje ścieżkę pliku i komunikat o błędzie do podsumowania, podczas gdy pętla kontynuuje przetwarzanie pozostałych plików. Plik logowania pod adresem batch_debug.log zapisuje szczegóły na poziomie silnika dla każdego pliku, który wyzwala wewnętrzne diagnozy.

Dla nieblokującego wykonania w serwisach lub aplikacjach webowych, IronOCR wspiera ReadAsync, który używa tej samej struktury try-catch.

Jeśli linia działa bez błędów, ale wyodrębniony tekst jest nadal niepoprawny, przyczyna leży prawie zawsze po stronie jakości obrazu, a nie kodu. Oto jak się do tego zabrać.

Jak debugować dokładność OCR?

Jeśli wyniki zaufania są konsekwentnie niskie, problemem jest źródłowy obraz, a nie silnik OCR. IronOCR zapewnia narzędzia do przedprzetwarzania, aby to rozwiązać:

Zastosuj filtry jakości obrazu, takie jak wyostrzanie, usuwanie szumów, dylatacja i erozja, aby poprawić klarowność tekstu
Użyj korekcji orientacji, aby automatycznie odchylić i obrócić zeskanowane dokumenty
Dostosuj ustawienie DPI dla obrazów o małej rozdzielczości przed przetworzeniem
Użyj widzenia komputerowego, aby wykrywać i izolować regiony tekstowe w złożonych układach
Narzędzie IronOCR pozwala na wizualne testowanie kombinacji filtrów i eksportowanie optymalnej konfiguracji C#

Dla problemów specyficznych dla wdrożenia, IronOCR utrzymuje dedykowane przewodniki do rozwiązywania problemów dla Azure Functions, Docker i Linux oraz ogólnej konfiguracji środowiska.

Gdzie powinienem się udać dalej?

Teraz, gdy zrozumiałeś, jak debugować IronOCR w czasie wykonania, odkryj:

Nawigowanie po strukturze wyników OCR i metadanych, w tym strony, bloki, akapity, słowa i współrzędne
Zrozumienie wyników zaufania na każdym poziomie hierarchii wyników
Używanie async i wielowątkowości z ReadAsync dla wysokowydajnych pipelinów
Przeglądanie pełnej dokumentacji API dla pełnej listy właściwości

Dla zastosowania w produkcji, pamiętaj, aby uzyskać licencję, aby usunąć znaki wodne i mieć pełen dostęp do funkcjonalności.

Często Zadawane Pytania

Jakie są najczęstsze problemy podczas debugowania OCR w C#?

Częste problemy obejmują nieprawidłowe wyniki OCR, niskie oceny pewności i nieoczekiwane wyjątki. IronOCR dostarcza narzędzia, takie jak logowanie i ocenianie pewności, które pomagają identyfikować i rozwiązywać te problemy.

Jak IronOCR wspomaga obsługę błędów w C#?

IronOCR oferuje typowane wyjątki i szczegółowe komunikaty o błędach, które pomagają w zrozumieniu i skutecznej obsłudze błędów podczas operacji OCR w aplikacjach C#.

Jakie funkcje logowania oferuje IronOCR do debugowania?

IronOCR zawiera wbudowane funkcje logowania, które pomagają śledzić procesy OCR i identyfikować potencjalne problemy poprzez rejestrowanie szczegółowych informacji o operacjach OCR.

Jak ocenianie pewności może poprawić wyniki OCR?

Ocenianie pewności w IronOCR pomaga określić dokładność rozpoznanego tekstu, umożliwiając programistom skupienie się na obszarach o niskiej pewności i poprawienie wyników OCR.

Czy mogę śledzić postęp zadań OCR używając IronOCR?

Tak, IronOCR zapewnia funkcje śledzenia postępu, które umożliwiają programistom monitorowanie stanu i trwania zadań OCR, co ułatwia zarządzanie zasobami i optymalizację wydajności.

Jakie wzorce try-catch są zalecane do obsługi błędów OCR?

IronOCR sugeruje użycie wzorców try-catch gotowych do produkcji, aby łagodnie obsługiwać wyjątki, zapewniając, że aplikacje OCR pozostaną solidne i łatwe w utrzymaniu.

Jak wbudowane narzędzia IronOCR mogą ulepszyć debugowanie OCR?

Narzędzia IronOCR, takie jak logowanie, typowane wyjątki i punkty pewności, zapewniają wszechstronne wsparcie w identyfikacji i rozwiązywaniu problemów, tym samym ulepszając proces debugowania.

Dlaczego rejestrowanie błędów jest ważne w aplikacjach OCR?

Rejestrowanie błędów jest kluczowe, ponieważ dostarcza informacji o tym, co poszło nie tak podczas przetwarzania OCR, umożliwiając programistom szybkie diagnozowanie i naprawianie problemów w ich aplikacjach.

Jaką rolę odgrywają typowane wyjątki w debugowaniu IronOCR?

Typowane wyjątki w IronOCR dostarczają szczegółowych informacji o błędach, co ułatwia programistom zrozumienie natury problemu i zastosowanie odpowiednich rozwiązań podczas debugowania.

Jak deweloperzy mogą skorzystać z funkcji debugowania IronOCR?

Deweloperzy mogą wykorzystać funkcje debugowania IronOCR do efektywnego rozwiązywania problemów, poprawy stabilności aplikacji i poprawy ogólnej jakości wyników OCR.

Curtis Chau

Czat z zespołem inżynierów teraz

Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.

...

Czytaj więcej