Zanim przeczytasz choćby jeden wynik OCR z Tesseract, napisałeś potok przetwarzania wstępnego — konwersję do skali szarości, wzmocnienie kontrastu, binarizację, usuwanie szumów, prostowanie, skalowanie DPI — około 180 linii kodu do obróbki obrazu, który nie ma nic wspólnego z rozpoznawaniem tekstu. Oto prawdziwy koszt opakowania Tesseract autorstwa charlesw: nie jest to zerowa opłata licencyjna, ale 20–40 godzin pracy inżynierów, aby silnik działał niezawodnie na dokumentach, które nie zostały zeskanowane w idealnych warunkach. Wtedy okazuje się, że aplikacja odbiera pliki PDF, a proces trzeba rozpocząć od nowa, dodając na początku bibliotekę do renderowania plików PDF.

Zrozumienie Tesseract

Pakiet Tesseract NuGet (wrapper charlesw) jest mostkiem P/Invoke, który udostępnia natywny silnik OCR Tesseract dla aplikacji .NET. Obejmuje bibliotekę przetwarzania obrazów Leptonica oraz pliki binarne silnika Tesseract, zapewniając programistom C# bezpośredni dostęp do jednego z najwydajniejszych silników OCR typu open source dostępnych na rynku.

Sam Tesseract stanowi podstawę technologii OCR w świecie oprogramowania open source. Silnik, pierwotnie opracowany w firmie Hewlett-Packard w latach 80. i udostępniony na licencji open source przez Google w 2005 r., zgromadził prawie 8 milionów pobrań z NuGet wyłącznie za pośrednictwem opakowania charlesw. Liczba ta odzwierciedla rzeczywistą użyteczność, a nie projekt niszowy. Gdy obrazy są czyste i dobrze sformatowane, Tesseract osiąga dokładność na poziomie ponad 95% przy minimalnej konfiguracji.

Kluczowe fakty architektoniczne, które kształtują każde zastosowanie tej biblioteki w środowisku produkcyjnym:

• Wejście wyłącznie obrazówe: Tesseract przetwarza obrazy. Nie posiada wewnętrznego renderera PDF. Każdy proces obsługi plików PDF wymaga osobnej biblioteki (PdfiumViewer, PDFtoImage, Docnet.Core, GhostScript) do konwersji każdej strony na obraz, zanim Tesseract będzie mógł ją przetworzyć.
• Wymagane ręczne przetwarzanie wstępne: Tesseract oczekuje czystych obrazów o wysokiej rozdzielczości i prawidłowej orientacji. Nie zawiera wbudowanych filtrów. Przechylenie, szumy, niska rozdzielczość (DPI) i kolorowe tła pogarszają dokładność bez korekty, a za tę korektę odpowiada wyłącznie programista.
• Zarządzanie plikami tessdata: Rozpoznawanie języka zależy od plików .traineddata pobranych z GitHub i umieszczonych w folderze tessdata. Pliki w każdym języku mają rozmiar od 15 do 100 MB. Każde środowisko — programistyczne, CI, stagingowe, produkcyjne,Docker— musi mieć odpowiednie pliki w odpowiedniej ścieżce.
• Natywne wdrożenie binarne: Wrapper zawiera natywne biblioteki specyficzne dla platformy (tesseract50.dll, leptonica-1.82.0.dll na Windows; pliki .so na Linuxie). Narzędzia te muszą być wdrażane wraz z aplikacją i dostosowane do architektury docelowej.
• Silnik niebezpieczny dla wątków: Instancja TesseractEngine nie może być współdzielona pomiędzy wątkami. Przetwarzanie równoległe wymaga utworzenia jednego silnika na wątek, co powoduje pomnożenie zajmowanej przez inicjalizację silnika pamięci (40–100 MB) przez stopień równoległości.
• Wersja Tesseract ustalona na 4.1.1: Oprogramowanie typu wrapper charlesw śledzi wersję Tesseract 4.1.1, wydaną w 2019 roku. Tesseract 5.x z ulepszoną dokładnością LSTM nie jest dostępny w tym pakiecie.

Luka w przetwarzaniu wstępnym

Wymóg przetwarzania wstępnego nie jest opcją konfiguracyjną, którą można pominąć. Stanowi on różnicę między dokładnością w środowisku produkcyjnym a bezużytecznym wynikiem w rzeczywistych dokumentach. Plik źródłowy image-preprocessing-tesseract.cs tego wrappera dokumentuje pełny manualny proces:

// Tesseract requires every one of these steps to be written manually
public static string ExtractWithPreprocessing(string imagePath)
{
    using (var original = new Bitmap(imagePath))
    {
        // Step 2: Convert to grayscale (~25 lines)
        using (var grayscale = ConvertToGrayscale(original))
        {
            // Step 3: Apply contrast enhancement (~15 lines)
            using (var enhanced = EnhanceContrast(grayscale))
            {
                // Step 4: Binarize — convert to black and white (~15 lines)
                using (var binarized = Binarize(enhanced, 128))
                {
                    // Step 5: Remove noise (~25 lines)
                    using (var denoised = RemoveNoise(binarized))
                    {
                        // Step 6: Wyrównanie if rotated (~50 lines, simplified)
                        using (var deskewed = Deskew(denoised))
                        {
                            // Step 7: Scale to 300 DPI (~20 lines)
                            using (var scaled = ScaleToDpi(deskewed, 300))
                            {
                                return RunTesseract(scaled);  // Save to temp file, load Pix, process
                            }
                        }
                    }
                }
            }
        }
    }
}

// Tesseract requires every one of these steps to be written manually
public static string ExtractWithPreprocessing(string imagePath)
{
    using (var original = new Bitmap(imagePath))
    {
        // Step 2: Convert to grayscale (~25 lines)
        using (var grayscale = ConvertToGrayscale(original))
        {
            // Step 3: Apply contrast enhancement (~15 lines)
            using (var enhanced = EnhanceContrast(grayscale))
            {
                // Step 4: Binarize — convert to black and white (~15 lines)
                using (var binarized = Binarize(enhanced, 128))
                {
                    // Step 5: Remove noise (~25 lines)
                    using (var denoised = RemoveNoise(binarized))
                    {
                        // Step 6: Wyrównanie if rotated (~50 lines, simplified)
                        using (var deskewed = Deskew(denoised))
                        {
                            // Step 7: Scale to 300 DPI (~20 lines)
                            using (var scaled = ScaleToDpi(deskewed, 300))
                            {
                                return RunTesseract(scaled);  // Save to temp file, load Pix, process
                            }
                        }
                    }
                }
            }
        }
    }
}

Ta zagnieżdżona struktura using to nie szablon, każdy krok to rzeczywista implementacja: matryca kolorów dla skali szarości, iteracja pikseli dla kontrastu, kolejna iteracja pikseli dla binaryzacji, filtr medianowy dla szumu i substytut transformacji Hougha dla prostowania. Plik źródłowy image-preprocessing-tesseract.cs bezpośrednio notuje: "Uproszczone prostowanie – rzeczywista implementacja wymaga transformacji Hougha. Zazwyczaj wymaga to biblioteki OpenCV lub podobnej.

Łącznie: około 180 wierszy, zanim przeczytasz choćby jedno słowo. Tabela dokładności w tym samym pliku pokazuje, dlaczego inwestycja jest konieczna — Tesseract bez wstępnego przetwarzania dokumentu o 5-stopniowym przekrzywieniu zapewnia 60–70% dokładności, podczas gdy prawidłowo przetworzone dane wejściowe osiągają ponad 90%.

Zrozumienie IronOCR

IronOCR to komercyjna biblioteka OCR dla platformy .NET, która zawiera zoptymalizowany silnik Tesseract 5 LSTM wraz z wbudowanym potokiem przetwarzania wstępnego, natywną obsługą plików PDF oraz zarządzanym interfejsem API, który nie wymaga zarządzania natywnymi plikami binarnymi. Biblioteka instaluje się jako pojedynczy pakiet NuGet bez folderów tessdata, bez kroków wdrażania bibliotek DLL specyficznych dla platformy i bez dodatkowych bibliotek renderowania PDF.

Kluczowe cechy charakteryzujące projekt IronOCR:

• Automatyczne przetwarzanie wstępne: Prostowanie, Usuwanie szumów, Kontrast, Binaryzacja i Poprawa rozdzielczości to jednoliniowe wywołania metod na OcrInput. Silnik domyślnie stosuje również inteligentne automatyczne przetwarzanie wstępne przed rozpoczęciem OCR.
• Natywne wejście PDF: input.LoadPdf() akceptuje zeskanowane PDF-y, cyfrowe PDF-y i mieszane PDF-y bez zewnętrznych zależności. Pliki PDF chronione hasłem wymagają jednego dodatkowego parametru.
• 125+ języków przez NuGet: Pakiety językowe instalowane są jako standardowe pakiety NuGet — IronOcr.Languages.French, IronOcr.Languages.Arabic — i nie wymagają zarządzania folderami ani konfiguracji ścieżek.
• Instancja IronTesseract bezpieczna dla wątków: Pojedyncza instancja obsługuje wszystkie wątki jednocześnie. Równoległe przetwarzanie wsadowe nie wymaga inicjalizacji silnika dla każdego wątku.
• Pojedynczy pakiet na wiele platform: Windows, Linux, macOS, Docker, Azure i AWS — wszystkie wdrażane są z tego samego pakietu NuGet bez konfiguracji specyficznej dla danej platformy.
• Plik PDF z możliwością wyszukiwania: Wyniki OCR są konwertowane na plik PDF z możliwością wyszukiwania za pomocą jednego wywołania metody.
• Cennik: $999 Lite perpetual / $1,499 Plus / $2,399 Professional / $4,799 Unlimited — jednorazowy zakup, bez opłat za dokument.

Porównanie funkcji

Szczegółowe porównanie funkcji

Luka w przetwarzaniu wstępnym

Wymóg dotyczący przetwarzania wstępnego jest powodem, dla którego szacowany czas pracy wynosi 20–40 godzin. To nie jest przesada. Zbudowanie od podstaw niezawodnego potoku przetwarzania wstępnego przy użyciu Tesseract oznacza wdrożenie każdej transformacji, którąIronOCR ma wbudowaną.

Podejście Tesseract

Kompletny proces przetwarzania wstępnego pokazany w image-preprocessing-tesseract.cs wymaga System.Drawing.Common (tylko Windows) lub dodatkowej biblioteki międzyplatformowej, takiej jak ImageSharp. Sama implementacja prostowania notuje, że jest uproszczona — algorytm produkcyjny do wykrywania przekrzywienia wymaga transformacji liniowej Hougha, co zazwyczaj oznacza wprowadzenie OpenCvSharp4 jako dodatkowej zależności:

// image-preprocessing-tesseract.cs — the actual implementation pattern
private static Bitmap ConvertToGrayscale(Bitmap original)
{
    var result = new Bitmap(original.Width, original.Height);
    using (var graphics = Graphics.FromImage(result))
    {
        var colorMatrix = new ColorMatrix(new float[][]
        {
            new float[] { 0.299f, 0.299f, 0.299f, 0, 0 },
            new float[] { 0.587f, 0.587f, 0.587f, 0, 0 },
            new float[] { 0.114f, 0.114f, 0.114f, 0, 0 },
            new float[] { 0, 0, 0, 1, 0 },
            new float[] { 0, 0, 0, 0, 1 }
        });
        using (var attributes = new ImageAttributes())
        {
            attributes.SetColorMatrix(colorMatrix);
            graphics.DrawImage(original,
                new Rectangle(0, 0, original.Width, original.Height),
                0, 0, original.Width, original.Height,
                GraphicsUnit.Pixel, attributes);
        }
    }
    return result;
}

private static Bitmap EnhanceContrast(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    float contrast = 1.5f;
    for (int y = 0; y < image.Height; y++)
    {
        for (int x = 0; x < image.Width; x++)
        {
            var pixel = image.GetPixel(x, y);
            int r = Clamp((int)((pixel.R - 128) * contrast + 128));
            int g = Clamp((int)((pixel.G - 128) * contrast + 128));
            int b = Clamp((int)((pixel.B - 128) * contrast + 128));
            result.SetPixel(x, y, Color.FromArgb(r, g, b));
        }
    }
    return result;
}

private static Bitmap RemoveNoise(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    int kernelSize = 3;
    int radius = kernelSize / 2;
    for (int y = radius; y < image.Height - radius; y++)
    {
        for (int x = radius; x < image.Width - radius; x++)
        {
            var pixels = new List<int>();
            for (int ky = -radius; ky <= radius; ky++)
                for (int kx = -radius; kx <= radius; kx++)
                    pixels.Add(image.GetPixel(x + kx, y + ky).R);
            pixels.Sort();
            int median = pixels[pixels.Count / 2];
            result.SetPixel(x, y, Color.FromArgb(median, median, median));
        }
    }
    return result;
}

// After all preprocessing, save to temp file — Tesseract requires a file path
private static string RunTesseract(Bitmap preprocessed)
{
    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        preprocessed.Save(tempPath, ImageFormat.Png);
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        using (var img = Pix.LoadFromFile(tempPath))
        using (var page = engine.Process(img))
            return page.GetText();
    }
    finally
    {
        if (File.Exists(tempPath)) File.Delete(tempPath);
    }
}

// image-preprocessing-tesseract.cs — the actual implementation pattern
private static Bitmap ConvertToGrayscale(Bitmap original)
{
    var result = new Bitmap(original.Width, original.Height);
    using (var graphics = Graphics.FromImage(result))
    {
        var colorMatrix = new ColorMatrix(new float[][]
        {
            new float[] { 0.299f, 0.299f, 0.299f, 0, 0 },
            new float[] { 0.587f, 0.587f, 0.587f, 0, 0 },
            new float[] { 0.114f, 0.114f, 0.114f, 0, 0 },
            new float[] { 0, 0, 0, 1, 0 },
            new float[] { 0, 0, 0, 0, 1 }
        });
        using (var attributes = new ImageAttributes())
        {
            attributes.SetColorMatrix(colorMatrix);
            graphics.DrawImage(original,
                new Rectangle(0, 0, original.Width, original.Height),
                0, 0, original.Width, original.Height,
                GraphicsUnit.Pixel, attributes);
        }
    }
    return result;
}

private static Bitmap EnhanceContrast(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    float contrast = 1.5f;
    for (int y = 0; y < image.Height; y++)
    {
        for (int x = 0; x < image.Width; x++)
        {
            var pixel = image.GetPixel(x, y);
            int r = Clamp((int)((pixel.R - 128) * contrast + 128));
            int g = Clamp((int)((pixel.G - 128) * contrast + 128));
            int b = Clamp((int)((pixel.B - 128) * contrast + 128));
            result.SetPixel(x, y, Color.FromArgb(r, g, b));
        }
    }
    return result;
}

private static Bitmap RemoveNoise(Bitmap image)
{
    var result = new Bitmap(image.Width, image.Height);
    int kernelSize = 3;
    int radius = kernelSize / 2;
    for (int y = radius; y < image.Height - radius; y++)
    {
        for (int x = radius; x < image.Width - radius; x++)
        {
            var pixels = new List<int>();
            for (int ky = -radius; ky <= radius; ky++)
                for (int kx = -radius; kx <= radius; kx++)
                    pixels.Add(image.GetPixel(x + kx, y + ky).R);
            pixels.Sort();
            int median = pixels[pixels.Count / 2];
            result.SetPixel(x, y, Color.FromArgb(median, median, median));
        }
    }
    return result;
}

// After all preprocessing, save to temp file — Tesseract requires a file path
private static string RunTesseract(Bitmap preprocessed)
{
    string tempPath = Path.GetTempFileName() + ".png";
    try
    {
        preprocessed.Save(tempPath, ImageFormat.Png);
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        using (var img = Pix.LoadFromFile(tempPath))
        using (var page = engine.Process(img))
            return page.GetText();
    }
    finally
    {
        if (File.Exists(tempPath)) File.Delete(tempPath);
    }
}

Imports System.Drawing
Imports System.Drawing.Imaging
Imports Tesseract
Imports System.IO

' image-preprocessing-tesseract.vb — the actual implementation pattern
Private Shared Function ConvertToGrayscale(original As Bitmap) As Bitmap
    Dim result As New Bitmap(original.Width, original.Height)
    Using graphics As Graphics = Graphics.FromImage(result)
        Dim colorMatrix As New ColorMatrix(New Single()() {
            New Single() {0.299F, 0.299F, 0.299F, 0, 0},
            New Single() {0.587F, 0.587F, 0.587F, 0, 0},
            New Single() {0.114F, 0.114F, 0.114F, 0, 0},
            New Single() {0, 0, 0, 1, 0},
            New Single() {0, 0, 0, 0, 1}
        })
        Using attributes As New ImageAttributes()
            attributes.SetColorMatrix(colorMatrix)
            graphics.DrawImage(original, New Rectangle(0, 0, original.Width, original.Height), 0, 0, original.Width, original.Height, GraphicsUnit.Pixel, attributes)
        End Using
    End Using
    Return result
End Function

Private Shared Function EnhanceContrast(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim contrast As Single = 1.5F
    For y As Integer = 0 To image.Height - 1
        For x As Integer = 0 To image.Width - 1
            Dim pixel As Color = image.GetPixel(x, y)
            Dim r As Integer = Clamp(CInt((pixel.R - 128) * contrast + 128))
            Dim g As Integer = Clamp(CInt((pixel.G - 128) * contrast + 128))
            Dim b As Integer = Clamp(CInt((pixel.B - 128) * contrast + 128))
            result.SetPixel(x, y, Color.FromArgb(r, g, b))
        Next
    Next
    Return result
End Function

Private Shared Function RemoveNoise(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim kernelSize As Integer = 3
    Dim radius As Integer = kernelSize \ 2
    For y As Integer = radius To image.Height - radius - 1
        For x As Integer = radius To image.Width - radius - 1
            Dim pixels As New List(Of Integer)()
            For ky As Integer = -radius To radius
                For kx As Integer = -radius To radius
                    pixels.Add(image.GetPixel(x + kx, y + ky).R)
                Next
            Next
            pixels.Sort()
            Dim median As Integer = pixels(pixels.Count \ 2)
            result.SetPixel(x, y, Color.FromArgb(median, median, median))
        Next
    Next
    Return result
End Function

' After all preprocessing, save to temp file — Tesseract requires a file path
Private Shared Function RunTesseract(preprocessed As Bitmap) As String
    Dim tempPath As String = Path.GetTempFileName() & ".png"
    Try
        preprocessed.Save(tempPath, ImageFormat.Png)
        Using engine As New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            Using img As Pix = Pix.LoadFromFile(tempPath)
                Using page As Page = engine.Process(img)
                    Return page.GetText()
                End Using
            End Using
        End Using
    Finally
        If File.Exists(tempPath) Then File.Delete(tempPath)
    End Try
End Function

Private Shared Function Clamp(value As Integer) As Integer
    Return Math.Max(0, Math.Min(255, value))
End Function

Private Const TessDataPath As String = "path_to_tessdata" ' Define the path to tessdata directory

Imports System.Drawing
Imports System.Drawing.Imaging
Imports Tesseract
Imports System.IO

' image-preprocessing-tesseract.vb — the actual implementation pattern
Private Shared Function ConvertToGrayscale(original As Bitmap) As Bitmap
    Dim result As New Bitmap(original.Width, original.Height)
    Using graphics As Graphics = Graphics.FromImage(result)
        Dim colorMatrix As New ColorMatrix(New Single()() {
            New Single() {0.299F, 0.299F, 0.299F, 0, 0},
            New Single() {0.587F, 0.587F, 0.587F, 0, 0},
            New Single() {0.114F, 0.114F, 0.114F, 0, 0},
            New Single() {0, 0, 0, 1, 0},
            New Single() {0, 0, 0, 0, 1}
        })
        Using attributes As New ImageAttributes()
            attributes.SetColorMatrix(colorMatrix)
            graphics.DrawImage(original, New Rectangle(0, 0, original.Width, original.Height), 0, 0, original.Width, original.Height, GraphicsUnit.Pixel, attributes)
        End Using
    End Using
    Return result
End Function

Private Shared Function EnhanceContrast(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim contrast As Single = 1.5F
    For y As Integer = 0 To image.Height - 1
        For x As Integer = 0 To image.Width - 1
            Dim pixel As Color = image.GetPixel(x, y)
            Dim r As Integer = Clamp(CInt((pixel.R - 128) * contrast + 128))
            Dim g As Integer = Clamp(CInt((pixel.G - 128) * contrast + 128))
            Dim b As Integer = Clamp(CInt((pixel.B - 128) * contrast + 128))
            result.SetPixel(x, y, Color.FromArgb(r, g, b))
        Next
    Next
    Return result
End Function

Private Shared Function RemoveNoise(image As Bitmap) As Bitmap
    Dim result As New Bitmap(image.Width, image.Height)
    Dim kernelSize As Integer = 3
    Dim radius As Integer = kernelSize \ 2
    For y As Integer = radius To image.Height - radius - 1
        For x As Integer = radius To image.Width - radius - 1
            Dim pixels As New List(Of Integer)()
            For ky As Integer = -radius To radius
                For kx As Integer = -radius To radius
                    pixels.Add(image.GetPixel(x + kx, y + ky).R)
                Next
            Next
            pixels.Sort()
            Dim median As Integer = pixels(pixels.Count \ 2)
            result.SetPixel(x, y, Color.FromArgb(median, median, median))
        Next
    Next
    Return result
End Function

' After all preprocessing, save to temp file — Tesseract requires a file path
Private Shared Function RunTesseract(preprocessed As Bitmap) As String
    Dim tempPath As String = Path.GetTempFileName() & ".png"
    Try
        preprocessed.Save(tempPath, ImageFormat.Png)
        Using engine As New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            Using img As Pix = Pix.LoadFromFile(tempPath)
                Using page As Page = engine.Process(img)
                    Return page.GetText()
                End Using
            End Using
        End Using
    Finally
        If File.Exists(tempPath) Then File.Delete(tempPath)
    End Try
End Function

Private Shared Function Clamp(value As Integer) As Integer
    Return Math.Max(0, Math.Min(255, value))
End Function

Private Const TessDataPath As String = "path_to_tessdata" ' Define the path to tessdata directory

To jest prawdziwy kod z plików źródłowych — nie jest to wymyślony najgorszy przypadek. Podejście oparte na iteracji pikseli w celu usunięcia kontrastu i szumu działa w czasie O(n²) dla każdego piksela. Zapisywanie i wczytywanie plików tymczasowych nie jest opcjonalne; Pix.LoadFromFile wymaga ścieżki pliku na dysku. W przypadku aplikacji przetwarzającej 1000 zeskanowanych dokumentów dziennie stanowi to wymierny koszt dodatkowy oprócz czasu potrzebnego na OCR.

Podejście IronOCR

To samo przetwarzanie wstępne w IronOCR to sekwencja wywołań metod na OcrInput:

// dotnet add package IronOcr
using IronOcr;

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

input.Deskew();           // Detects and corrects skew angle automatically
input.DeNoise();          // Removes scanner artifacts and specks
input.Contrast();         // Enhances contrast for character separation
input.Binarize();         // Converts to black and white with adaptive threshold
input.EnhanceResolution(300);  // Scales to 300 DPI for optimal recognition

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

// dotnet add package IronOcr
using IronOcr;

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

input.Deskew();           // Detects and corrects skew angle automatically
input.DeNoise();          // Removes scanner artifacts and specks
input.Contrast();         // Enhances contrast for character separation
input.Binarize();         // Converts to black and white with adaptive threshold
input.EnhanceResolution(300);  // Scales to 300 DPI for optimal recognition

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

Imports IronOcr

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

input.Deskew()           ' Detects and corrects skew angle automatically
input.DeNoise()          ' Removes scanner artifacts and specks
input.Contrast()         ' Enhances contrast for character separation
input.Binarize()         ' Converts to black and white with adaptive threshold
input.EnhanceResolution(300)  ' Scales to 300 DPI for optimal recognition

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

Imports IronOcr

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

input.Deskew()           ' Detects and corrects skew angle automatically
input.DeNoise()          ' Removes scanner artifacts and specks
input.Contrast()         ' Enhances contrast for character separation
input.Binarize()         ' Converts to black and white with adaptive threshold
input.EnhanceResolution(300)  ' Scales to 300 DPI for optimal recognition

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

Brak plików tymczasowych. Bez powtarzania pikseli. Brak zależności od System.Drawing.Common lub OpenCvSharp4. Przewodnik po korekcji jakości obrazu oraz przewodnik po korekcji orientacji obrazu obejmują pełny katalog filtrów — dostępnych jest ponad 15. Przykład filtrów obrazu pokazuje cały proces skanowania o niskiej jakości od początku do końca.

W przypadku większości rzeczywistych dokumentów domyślny odczyt stosuje inteligentne automatyczne przetwarzanie wstępne bez żadnych jawnych wywołań filtrów:

// Automatic preprocessing applied internally — no explicit filter calls needed
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

// Automatic preprocessing applied internally — no explicit filter calls needed
var text = new IronTesseract().Read("scanned-invoice.jpg").Text;

Imports IronTesseract

' Automatic preprocessing applied internally — no explicit filter calls needed
Dim text As String = New IronTesseract().Read("scanned-invoice.jpg").Text

Imports IronTesseract

' Automatic preprocessing applied internally — no explicit filter calls needed
Dim text As String = New IronTesseract().Read("scanned-invoice.jpg").Text

W przypadku czystego wejścia o wysokiej rozdzielczości nie wiąże się to z żadnymi kosztami. Na zdjęciu wykonanym telefonem o rozdzielczości 72 DPI silnik skaluje, poprawia i normalizuje obraz przed rozpoznaniem tekstu.

Luka w pliku PDF

PDF jest standardowym formatem dostarczania dokumentów biznesowych. Umowy, faktury, wyciągi bankowe, dokumentacja medyczna — wszystkie te dokumenty otrzymujemy w formacie PDF. Tesseract nie może otworzyć pliku PDF. Zbudowanie mostka wymaga kolejnej biblioteki, kolejnej natywnej zależności i kolejnych 50–150 linii kodu łączącego.

Podejście Tesseract

Plik pdf-ocr-processing-tesseract.cs dokumentuje trzy osobne opcje bibliotek renderujących PDF — PdfiumViewer, PDFtoImage i Docnet.Core — każda z różnymi łańcuchami zależności i kompromisami. Wzorzec PdfiumViewer przedstawiony w tym pliku jest reprezentatywny:

// Tesseract PDF processing — from pdf-ocr-processing-tesseract.cs
// Requires: PdfiumViewer NuGet + pdfium native DLL deployed to application directory
// NuGet: PdfiumViewer, PdfiumViewer.Native.x64

using PdfiumViewer;

public static string ExtractFromPdfWithPdfium(string pdfPath)
{
    var results = new List<string>();

    using (var document = PdfDocument.Load(pdfPath))
    {
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        {
            for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
            {
                // Render page to image at 300 DPI
                using (var pageImage = document.Render(pageIndex, 300, 300,
                    PdfRenderFlags.CorrectFromDpi))
                {
                    // Tesseract requires a file path — must write to disk first
                    string tempPath = Path.GetTempFileName() + ".png";
                    try
                    {
                        pageImage.Save(tempPath);
                        using (var img = Pix.LoadFromFile(tempPath))
                        using (var page = engine.Process(img))
                            results.Add(page.GetText());
                    }
                    finally
                    {
                        File.Delete(tempPath);  // Must clean up or disk fills
                    }
                }
            }
        }
    }

    return string.Join("\n\n--- Page Break ---\n\n", results);
}

// Tesseract PDF processing — from pdf-ocr-processing-tesseract.cs
// Requires: PdfiumViewer NuGet + pdfium native DLL deployed to application directory
// NuGet: PdfiumViewer, PdfiumViewer.Native.x64

using PdfiumViewer;

public static string ExtractFromPdfWithPdfium(string pdfPath)
{
    var results = new List<string>();

    using (var document = PdfDocument.Load(pdfPath))
    {
        using (var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default))
        {
            for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
            {
                // Render page to image at 300 DPI
                using (var pageImage = document.Render(pageIndex, 300, 300,
                    PdfRenderFlags.CorrectFromDpi))
                {
                    // Tesseract requires a file path — must write to disk first
                    string tempPath = Path.GetTempFileName() + ".png";
                    try
                    {
                        pageImage.Save(tempPath);
                        using (var img = Pix.LoadFromFile(tempPath))
                        using (var page = engine.Process(img))
                            results.Add(page.GetText());
                    }
                    finally
                    {
                        File.Delete(tempPath);  // Must clean up or disk fills
                    }
                }
            }
        }
    }

    return string.Join("\n\n--- Page Break ---\n\n", results);
}

Imports PdfiumViewer
Imports Tesseract

Public Shared Function ExtractFromPdfWithPdfium(pdfPath As String) As String
    Dim results As New List(Of String)()

    Using document = PdfDocument.Load(pdfPath)
        Using engine = New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            For pageIndex As Integer = 0 To document.PageCount - 1
                ' Render page to image at 300 DPI
                Using pageImage = document.Render(pageIndex, 300, 300, PdfRenderFlags.CorrectFromDpi)
                    ' Tesseract requires a file path — must write to disk first
                    Dim tempPath As String = Path.GetTempFileName() & ".png"
                    Try
                        pageImage.Save(tempPath)
                        Using img = Pix.LoadFromFile(tempPath)
                            Using page = engine.Process(img)
                                results.Add(page.GetText())
                            End Using
                        End Using
                    Finally
                        File.Delete(tempPath)  ' Must clean up or disk fills
                    End Try
                End Using
            Next
        End Using
    End Using

    Return String.Join(vbCrLf & vbCrLf & "--- Page Break ---" & vbCrLf & vbCrLf, results)
End Function

Imports PdfiumViewer
Imports Tesseract

Public Shared Function ExtractFromPdfWithPdfium(pdfPath As String) As String
    Dim results As New List(Of String)()

    Using document = PdfDocument.Load(pdfPath)
        Using engine = New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            For pageIndex As Integer = 0 To document.PageCount - 1
                ' Render page to image at 300 DPI
                Using pageImage = document.Render(pageIndex, 300, 300, PdfRenderFlags.CorrectFromDpi)
                    ' Tesseract requires a file path — must write to disk first
                    Dim tempPath As String = Path.GetTempFileName() & ".png"
                    Try
                        pageImage.Save(tempPath)
                        Using img = Pix.LoadFromFile(tempPath)
                            Using page = engine.Process(img)
                                results.Add(page.GetText())
                            End Using
                        End Using
                    Finally
                        File.Delete(tempPath)  ' Must clean up or disk fills
                    End Try
                End Using
            Next
        End Using
    End Using

    Return String.Join(vbCrLf & vbCrLf & "--- Page Break ---" & vbCrLf & vbCrLf, results)
End Function

Źródło pdf-ocr-processing-tesseract.cs bezpośrednio notuje łańcuch zależności: "Tesseract: Apache 2.0, PdfiumViewer: BSD, iText: AGPL lub komercyjne, GhostScript: AGPL lub komercyjne." Ten ostatni punkt ma znaczenie w kontekstach biznesowych — licencja AGPL GhostScript wymaga, aby Twoja aplikacja była open-source, chyba że zakupisz komercyjną licencję GhostScript.

Pliki PDF chronione hasłem stanowią dodatkową warstwę zabezpieczeń. Klasa PasswordProtectedPdf w tym samym pliku wyrzuca NotImplementedException z komentarzem: "Wymaga biblioteki PDF z obsługą szyfrowania (iText, PDFSharp). "Tesseract nie może odszyfrowywać plików PDF". Zatem ochrona hasłem oznacza czwartą zależność, która wiąże się z własnymi kwestiami licencyjnymi.

Podejście IronOCR

IronOCR odczytuje pliki PDF w trybie natywnym, w tym zeskanowane pliki PDF, pliki PDF z tekstem cyfrowym, pliki PDF o mieszanej zawartości oraz pliki PDF chronione hasłem:

// dotnet add package IronOcr
using IronOcr;

// Scanned PDF — direct load, no rendering library required
var result = new IronTesseract().Read("scanned-contract.pdf");
Console.WriteLine(result.Text);

// Password-protected PDF — one additional parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var protectedResult = new IronTesseract().Read(input);

// Specific page range from a 200-page document
using var rangeInput = new OcrInput();
rangeInput.LoadPdfPages("large-report.pdf", 1, 10);
var rangeResult = new IronTesseract().Read(rangeInput);

// Create searchable PDF with embedded text layer
var searchable = new IronTesseract().Read("scanned-invoice.pdf");
searchable.SaveAsSearchablePdf("searchable-invoice.pdf");

// dotnet add package IronOcr
using IronOcr;

// Scanned PDF — direct load, no rendering library required
var result = new IronTesseract().Read("scanned-contract.pdf");
Console.WriteLine(result.Text);

// Password-protected PDF — one additional parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var protectedResult = new IronTesseract().Read(input);

// Specific page range from a 200-page document
using var rangeInput = new OcrInput();
rangeInput.LoadPdfPages("large-report.pdf", 1, 10);
var rangeResult = new IronTesseract().Read(rangeInput);

// Create searchable PDF with embedded text layer
var searchable = new IronTesseract().Read("scanned-invoice.pdf");
searchable.SaveAsSearchablePdf("searchable-invoice.pdf");

Imports IronOcr

' Scanned PDF — direct load, no rendering library required
Dim result = New IronTesseract().Read("scanned-contract.pdf")
Console.WriteLine(result.Text)

' Password-protected PDF — one additional parameter
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret")
    Dim protectedResult = New IronTesseract().Read(input)
End Using

' Specific page range from a 200-page document
Using rangeInput As New OcrInput()
    rangeInput.LoadPdfPages("large-report.pdf", 1, 10)
    Dim rangeResult = New IronTesseract().Read(rangeInput)
End Using

' Create searchable PDF with embedded text layer
Dim searchable = New IronTesseract().Read("scanned-invoice.pdf")
searchable.SaveAsSearchablePdf("searchable-invoice.pdf")

Imports IronOcr

' Scanned PDF — direct load, no rendering library required
Dim result = New IronTesseract().Read("scanned-contract.pdf")
Console.WriteLine(result.Text)

' Password-protected PDF — one additional parameter
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret")
    Dim protectedResult = New IronTesseract().Read(input)
End Using

' Specific page range from a 200-page document
Using rangeInput As New OcrInput()
    rangeInput.LoadPdfPages("large-report.pdf", 1, 10)
    Dim rangeResult = New IronTesseract().Read(rangeInput)
End Using

' Create searchable PDF with embedded text layer
Dim searchable = New IronTesseract().Read("scanned-invoice.pdf")
searchable.SaveAsSearchablePdf("searchable-invoice.pdf")

Brak biblioteki do renderowania plików PDF. Brak plików tymczasowych. Nie ma żadnych kwestii związanych z licencją AGPL. Podręcznik dotyczący wprowadzania danych z plików PDF obejmuje wszystkie warianty wprowadzania danych z plików PDF. W instrukcji w formacie PDF z funkcją wyszukiwania wyjaśniono sposób wyświetlania warstwy tekstowej. Dla zespołów tworzących potoki przetwarzania dokumentów strona poświęcona zastosowaniom OCR w plikach PDF zawiera wzorce architektury produkcyjnej.

Metody przetwarzania wstępnego działają identycznie na wejściu PDF, umożliwiając te same wywołania input.Deskew(), input.DeNoise(), input.EnhanceResolution() na zeskanowanych PDF-ach bez potrzeby kroków pośrednich.

Zarządzanie danymi Tessdata

Każde wdrożenie Tesseract obejmuje problem folderu tessdata. Folder musi istnieć, być wypełniony odpowiednimi plikami .traineddata i być dostępny pod ścieżką określoną przy inicjalizacji TesseractEngine. Powoduje to złożoność wdrożenia, która rośnie wraz ze skalą.

Podejście Tesseract

Plik multi-language-tesseract.cs dokumentuje rozmiary plików językowych oraz proces zarządzania nimi:

// Must exist before initialization:
// ./tessdata/eng.traineddata   (~15 MB)
// ./tessdata/fra.traineddata   (~15 MB)
// ./tessdata/deu.traineddata   (~15 MB)
// ./tessdata/chi_sim.traineddata  (~45 MB)
// ./tessdata/jpn.traineddata   (~40 MB)
// 10 languages = 200-300 MB to download and manage

public string SafeMultiLanguageOcr(string imagePath, string[] languages)
{
    // Check presence before attempting — runtime failures are worse
    foreach (var lang in languages)
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
        {
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
        }
    }

    var langString = string.Join("+", languages);  // e.g., "eng+fra+deu"
    using var engine = new TesseractEngine(TessDataPath, langString, EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);
    return page.GetText();
}

// Must exist before initialization:
// ./tessdata/eng.traineddata   (~15 MB)
// ./tessdata/fra.traineddata   (~15 MB)
// ./tessdata/deu.traineddata   (~15 MB)
// ./tessdata/chi_sim.traineddata  (~45 MB)
// ./tessdata/jpn.traineddata   (~40 MB)
// 10 languages = 200-300 MB to download and manage

public string SafeMultiLanguageOcr(string imagePath, string[] languages)
{
    // Check presence before attempting — runtime failures are worse
    foreach (var lang in languages)
    {
        if (!File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")))
        {
            throw new FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " +
                "Download from https://github.com/tesseract-ocr/tessdata");
        }
    }

    var langString = string.Join("+", languages);  // e.g., "eng+fra+deu"
    using var engine = new TesseractEngine(TessDataPath, langString, EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);
    return page.GetText();
}

Imports System.IO
Imports Tesseract

Public Function SafeMultiLanguageOcr(imagePath As String, languages As String()) As String
    ' Check presence before attempting — runtime failures are worse
    For Each lang In languages
        If Not File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")) Then
            Throw New FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " &
                "Download from https://github.com/tesseract-ocr/tessdata")
        End If
    Next

    Dim langString = String.Join("+", languages)  ' e.g., "eng+fra+deu"
    Using engine As New TesseractEngine(TessDataPath, langString, EngineMode.Default)
        Using img As Pix = Pix.LoadFromFile(imagePath)
            Using page As Page = engine.Process(img)
                Return page.GetText()
            End Using
        End Using
    End Using
End Function

Imports System.IO
Imports Tesseract

Public Function SafeMultiLanguageOcr(imagePath As String, languages As String()) As String
    ' Check presence before attempting — runtime failures are worse
    For Each lang In languages
        If Not File.Exists(Path.Combine(TessDataPath, $"{lang}.traineddata")) Then
            Throw New FileNotFoundException(
                $"Missing {lang}.traineddata in {TessDataPath}. " &
                "Download from https://github.com/tesseract-ocr/tessdata")
        End If
    Next

    Dim langString = String.Join("+", languages)  ' e.g., "eng+fra+deu"
    Using engine As New TesseractEngine(TessDataPath, langString, EngineMode.Default)
        Using img As Pix = Pix.LoadFromFile(imagePath)
            Using page As Page = engine.Process(img)
                Return page.GetText()
            End Using
        End Using
    End Using
End Function

Defensywna kontrola istnienia plików to nie paranoja – brakujący plik .traineddata wyrzuca TesseractException: Failed to initialise tesseract engine z wiadomością, która nie zawsze jasno identyfikuje, który plik jest brakujący. Żródło basic-text-extraction-tesseract.cs dokumentuje typowe wyjątki czasu wykonania: System.DllNotFoundException za brakujące binaria Leptonica, TesseractException za brakujące tessdata, BadImageFormatException za niezgodność 32/64 bitów.

W przypadku wdrożeńDockerpliki tessdata muszą zostać skopiowane do obrazu kontenera. Dla trzech języków po 15 MB każdy plus modele best po 50-100 MB każdy, obrazy kontenerów puchną o kilkaset megabajtów. Pipeline'y CI/CD muszą albo buforować te pliki do pobrania, albo akceptować długi czas kompilacji, gdy pamięć podręczna jest pusta.

Podejście IronOCR

Obsługa języków w IronOCR jest odwołaniem do pakietu NuGet:

// Install once: dotnet add package IronOcr.Languages.French
// Install once: dotnet add package IronOcr.Languages.German
using IronOcr;

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

var result = ocr.Read("multilingual-document.jpg");

// Install once: dotnet add package IronOcr.Languages.French
// Install once: dotnet add package IronOcr.Languages.German
using IronOcr;

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

var result = ocr.Read("multilingual-document.jpg");

Imports IronOcr

' Install once: dotnet add package IronOcr.Languages.French
' Install once: dotnet add package IronOcr.Languages.German

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.French
ocr.AddSecondaryLanguage(OcrLanguage.German)

Dim result = ocr.Read("multilingual-document.jpg")

Imports IronOcr

' Install once: dotnet add package IronOcr.Languages.French
' Install once: dotnet add package IronOcr.Languages.German

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.French
ocr.AddSecondaryLanguage(OcrLanguage.German)

Dim result = ocr.Read("multilingual-document.jpg")

Dane językowe są osadzone w pakiecie NuGet. Nie trzeba tworzyć folderów, konfigurować ścieżek ani pobierać plików z GitHub i ich weryfikować. Dodanie języka do Dockera oznacza dodanie jednej linii PackageReference do .csproj. Wielojęzyczny przewodnik obejmuje pełny katalog ponad 125 języków, a wielojęzyczny wpis na blogu omawia produkcyjne procesy wielojęzyczne, w tym zestawy znaków CJK.

Przewodnik po mapowaniu API

Kiedy zespoły rozważają przejście z Tesseract na IronOCR

Nadchodzi etap przetwarzania wstępnego

Każdy projekt Tesseract rozpoczyna się od czystych obrazów testowych. Przykładowe faktury, wyraźnie zeskanowane dokumenty, pliki PNG o rozdzielczości 300 DPI, które działają już przy pierwszym odczycie. Kwestia przetwarzania wstępnego zostaje odłożona na później. Następnie przybywa pierwsza partia produkcyjna: zamówienia przesłane faksem w rozdzielczości 150 DPI, zeskanowane umowy z 3-stopniowym przekrzywieniem, zdjęcia paragonów wykonane w świetle fluorescencyjnym. Dokładność spada do 60–70%. Zespół stoi teraz przed zadaniem wdrożenia odłożonego wcześniej procesu przetwarzania wstępnego. Okazało się, że konwersja do skali szarości i wzmocnienie kontrastu są wykonalne, ale korekcja pochylenia wymaga transformacji Hougha, a usuwanie szumów wymaga filtra medianowego, a żadne z tych zadań nie jest zadaniem na dwie godziny. Zespoły na tym etapie — gdy zadłużenie związane z przetwarzaniem wstępnym staje się elementem sprintowego backlogu — często oceniają IronOCR, ponieważ koszt licencji jest tańszy niż dwa tygodnie pracy dewelopera nad przetwarzaniem obrazów, której nie wynajmowano.

Wymagania dotyczące pliku PDF

Aplikacje do przetwarzania dokumentów prawie zawsze w końcu potrzebują obsługi formatu PDF. Pierwszą odpowiedzią jest zazwyczaj "dodaj PdfiumViewer" — jest on dobrze udokumentowany i dobrze radzi sobie w wielu przypadkach. Problemy pojawiają się w produkcji: natywny pdfium.dll musi być obecny w katalogu aplikacji we właściwej wersji bitowej, obrazy kontenerów wymagają jawnych kroków COPY w Dockerfiles, wdrożenia Linuxa potrzebują odpowiedniego pliku .so, a PDF-y chronione hasłem wymagają osobnej biblioteki odszyfrowującej z własną licencją. Zespoły zarządzające trzema odrębnymi łańcuchami zależności — bibliotekami natywnymi Tesseract, Leptonica i pdfium — w czterech środowiskach (Windows, Linux, Docker, CI) osiągają próg konserwacji, przy którym warto rozważyć alternatywę w postaci jednego pakietu.

Przetwarzanie równoległe na dużą skalę

Zadanie OCR przetwarzające 500 faktur w partii korzysta z równoległości. W przypadku opakowania charlesw bezpieczny wzorzec przetwarzania równoległego tworzy jedną instancję silnika na wątek, ładując po 40–100 MB danych modelu językowego. Przy ośmiu wątkach oznacza to 320–800 MB pamięci silnika przed załadowaniem jakichkolwiek dokumentów. Zespoły analizujące swoje usługi OCR i stwierdzające, że obciążenie pamięci koncentruje się na inicjalizacji silnika — a nie na treści dokumentu — zauważają, że model pojedynczej instancji IronOCR, bezpieczny dla wątków, bezpośrednio rozwiązuje tę podstawową przyczynę. Przykład wielowątkowości ilustruje ten wzorzec.

Wzrost liczby środowisk wdrożeniowych

Projekt, który rozpoczął się w systemie Windows, dodaje kontenerLinuxdo wdrożenia w chmurze. Plik Dockerfile wymaga teraz kroków instalacji bibliotek natywnych, pliki tessdata muszą zostać skopiowane do kontenera, a zmienna środowiskowa ścieżki tessdata musi być poprawnie ustawiona. Następnie do zespołu dołącza programista macOS. Następnie ktoś chce wdrożyć rozwiązanie w AWS Lambda. Każda platforma dodaje kolejną powierzchnię konfiguracyjną, która może ulec cichej awarii — brak biblioteki natywnej w czasie wykonywania w kontenerze produkcyjnym jest gorszym scenariuszem niż nieco wyższy koszt pakietu NuGet. Przewodnik wdrażania IronOCR w Dockerze pokazuje tę różnicę: brak pakietów systemowych, brak etapu kopiowania danych tessdata, brak zmiennej środowiskowej.

Wersja Tesseract – kwestie walutowe

Wersja Tesseract 5.x wprowadziła ulepszenia w zakresie dokładności LSTM, które są mierzalne w przypadku niektórych typów dokumentów. Oprogramowanie typu wrapper charlesw jest przeznaczone dla Tesseract 4.1.1. Dla zespołów, w których dokładność OCR w przypadku trudnych dokumentów stanowi wskaźnik jakości produktu, różnica między wersjami jest istotnym czynnikiem — szczególnie gdy alternatywą jest komercyjnie utrzymywany pakiet śledzący aktualną wersję silnika.

Typowe kwestie związane z migracją

Usuwanie folderu Tessdata

Pierwszym krokiem czyszczenia po migracji do IronOCR jest usunięcie folderu tessdata i usunięcie odpowiadających mu elementów <Content Include="tessdata\**"> z pliku projektu. Każdy twardo zakodowany kod walidacji ścieżek — zabezpieczenie Directory.Exists(TessDataPath) obecne w basic-text-extraction-tesseract.cs — również zostaje usunięte. Odwołania do przestrzeni nazw using Tesseract; oraz referencje typów TesseractEngine, Pix, i Page wszystkie wymagają zamiany na using IronOcr;, IronTesseract, OcrInput, i OcrResult.

Usunięcie biblioteki PDF

Wszelkie biblioteki renderowania plików PDF dodane wyłącznie w celu obsługi przetwarzania plików PDF przez Tesseract — PdfiumViewer, PDFtoImage, Docnet.Core — można usunąć. Natywne zależności binarne, które wymagały te pakiety (pdfium.dll, pliki binarne GhostScript) również zostają usunięte. Linie Dockerfile COPY i apt-get dla tych zależności nie są już potrzebne. Przewodnik po formatach plików PDF obsługiwanych przez IronOCR obejmuje wszystkie warianty plików PDF obsługiwane przez te biblioteki, w tym wybór zakresu stron i dokumenty chronione hasłem. Cały blok render-then-OCR — zazwyczaj 50-80 wierszy obejmujących trzy biblioteki — redukuje się do input.LoadPdf(path), a następnie pojedynczego wywołania Read().

Wstępne przetwarzanie – zamiana kodu

Istniejące metody przetwarzania wstępnego — ConvertToGrayscale, EnhanceContrast, Binarize, RemoveNoise, Deskew, ScaleToDpi — bezpośrednio przekładają się na metody filtrów IronOCR. Wzorzec zapisywania i wczytywania plików tymczasowych całkowicie znika. W kwestii transformacji kolorów należy zapoznać się z przewodnikiem po korekcji kolorów, a w kwestii zarządzania rozdzielczością – z przewodnikiem po ustawieniach DPI.

Zmiana modelu wątków

Kod, który tworzy TesseractEngine wewnątrz pętli Parallel.ForEach — jeden na wątek — zmienia się na tworzenie IronTesseract raz przed pętlą i współdzielenie go pomiędzy wszystkimi wątkami. Jest to zmiana poprawiająca poprawność, a nie tylko refaktoryzacja: stary wzorzec polegał na programowaniu defensywnym wokół API niebezpiecznego dla wątków; Nowym wzorcem jest zamierzone wykorzystanie interfejsu API bezpiecznego dla wątków. Obciążenie związane z inicjalizacją silnika na wątek — 40–100 MB danych modelu językowego na wątek — znika wraz z tą zmianą, ponieważIronOCR utrzymuje wspólną pulę wewnętrzną zamiast ładować pełny stan modelu dla każdej instancji silnika.

Dodatkowe możliwości IronOCR

Oprócz przetwarzania wstępnego i obsługi plików PDF,IronOCR oferuje funkcje, które znacznie wykraczają poza podstawowe porównanie:

• OCR oparte na regionach: Wyodrębnianie tekstu z określonego prostokąta bez przetwarzania całego obrazu. Przewodnik po rozpoznawaniu znaków (OCR) dla regionu oraz przykład przycinania obejmują wyodrębnianie nagłówków faktur i izolowanie pól formularzy.
• Routing jakości oparty na pewności: result.Confidence zapewnia estymację dokładności na poziomie dokumentu, która umożliwia kierowanie wyników o niskiej pewności do kolejki przeglądu ręcznego bez ponownego uruchamiania OCR. Zobacz przewodnik po wynikach pewności.
• Async OCR: Przewodnik po asynchronicznym OCR obejmuje nieblokujące OCR dla aplikacji ASP.NET Core, w których blokowanie wątku żądania podczas operacji obciążającej procesor jest niedopuszczalne.
• Specjalistyczne typy dokumentów: odczyt paszportów, odczyt MICR/czeków oraz odczyt tablic rejestracyjnych są dostępne jako funkcje docelowe bez konieczności stosowania niestandardowych, wyszkolonych modeli.
• Konfiguracja prędkości: Przewodnik po optymalizacji prędkości oraz przykładowe opcje konfiguracji dokumentów do przetwarzania wsadowego o wysokiej przepustowości, gdzie liczy się opóźnienie na dokument.

Zgodność z platformą .NET i gotowość na przyszłość

IronOCR jest przeznaczony dla platform .NET 6, .NET 7, .NET 8 i .NET 9, a po premierze w 2026 r. będzie aktywnie wspierać platformę .NET 10. Biblioteka obsługuje również .NET Standard 2.0 dla projektów, które nie zostały jeszcze przeniesione do nowoczesnego środowiska .NET. Owijka charlesw Tesseract jest przeznaczona dla .NET Standard 2.0 i jest przypisana do silnika Tesseract w wersji 4.1.1 z 2019 r., bez ogłoszonego planu wsparcia dla Tesseract 5.x w ramach tego pakietu. W przypadku nowych projektów i zespołów planujących wieloletnie okresy konserwacji, różnica w wersjach silnika i spowolnienie tempa konserwacji opakowania są czynnikami, które warto rozważyć obok licencji bezpłatnej.

Wnioski

Tesseract za pośrednictwem opakowania NuGet charlesw to prawdziwy silnik OCR, a nie zabawka. Liczba 8 milionów pobrań odzwierciedla rzeczywiste wykorzystanie w prawdziwych aplikacjach, a na czystych, dobrze sformatowanych obrazach osiąga poziom dokładności, który uzasadnia jego popularność. Rzetelne porównanie nie dotyczy jakości OCR — dotyczy ono zakresu prac inżynieryjnych niezbędnych do zapewnienia tej jakości w warunkach produkcyjnych.

Luka w przetwarzaniu wstępnym stanowi główny kompromis. Około 180 linii kodu do obróbki obrazów, które odróżniają dobrą dokładność od słabej w rzeczywistych dokumentach, to nie jest drobna niedogodność. Jest to zadanie inżynieryjne, które wymaga wiedzy z zakresu przetwarzania obrazów, dodatkowych zależności oraz bieżącej konserwacji w miarę pojawiania się nowych typów dokumentów. Luka w formacie PDF dodaje kolejną warstwę: drugą bibliotekę, drugi zestaw natywnych plików binarnych, kolejną powierzchnię wdrożeniową oraz potencjalne komplikacje licencyjne związane z GhostScript lub iText. Te dwie luki łącznie odpowiadają za szacunkowy czas konfiguracji wynoszący 20–40 godzin, który odróżnia prototyp od systemu produkcyjnego.

IronOCR bezpośrednio wypełnia obie luki: przetwarzanie wstępne to wywołania metod w jednej linii, PDF jest natywnym formatem wejściowym, a całe rozwiązanie wdraża się jako pojedynczy pakiet NuGet. Bezterminowa licencja $999 to koszt unikania spędzenia dwóch tygodni na kodowaniu przetwarzania obrazów i zarządzaniu łańcuchem zależności. Dla zespołów, gdzie czas dewelopera kosztuje więcej niż cena licencji, obliczenia są proste. Dla zespołów, które muszą spełniać wymagania licencji open source lub mają zerowy budżet, Tesseract pozostaje najlepszym rozwiązaniem — przy pełnej świadomości związanych z tym nakładów inżynieryjnych.

Decyzja ta jasno odnosi się do typów dokumentów i kontekstu operacyjnego: czyste, kontrolowane obrazy w środowisku wdrożeniowym typu single-environment przemawiają na korzyść bezpłatnej licencji Tesseract. Skanowanie w rzeczywistych warunkach, przepływy pracy z plikami PDF, wdrażanie w wielu środowiskach oraz przetwarzanie równoległe na dużą skalę to czynniki, które sprawiają, że wybór pada na IronOCR. Większość systemów przetwarzania dokumentów produkcyjnych spełnia co najmniej dwa z tych warunków.