API OCR Microsoft Azure Vision vs. IronOCR: Które lepiej obsługuje obrazy dokumentów?

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

Imports System.Drawing

Public Class ImageProcessor
    Public Shared Function ExtractWithPreprocessing(imagePath As String) As String
        Using original As New Bitmap(imagePath)
            ' Step 2: Convert to grayscale (~25 lines)
            Using grayscale As Bitmap = ConvertToGrayscale(original)
                ' Step 3: Apply contrast enhancement (~15 lines)
                Using enhanced As Bitmap = EnhanceContrast(grayscale)
                    ' Step 4: Binarize — convert to black and white (~15 lines)
                    Using binarized As Bitmap = Binarize(enhanced, 128)
                        ' Step 5: Remove noise (~25 lines)
                        Using denoised As Bitmap = RemoveNoise(binarized)
                            ' Step 6: Deskew if rotated (~50 lines, simplified)
                            Using deskewed As Bitmap = Deskew(denoised)
                                ' Step 7: Scale to 300 DPI (~20 lines)
                                Using scaled As Bitmap = ScaleToDpi(deskewed, 300)
                                    Return RunTesseract(scaled)  ' Save to temp file, load Pix, process
                                End Using
                            End Using
                        End Using
                    End Using
                End Using
            End Using
        End Using
    End Function

    ' Placeholder methods for image processing steps
    Private Shared Function ConvertToGrayscale(original As Bitmap) As Bitmap
        ' Implementation here
        Return original
    End Function

    Private Shared Function EnhanceContrast(grayscale As Bitmap) As Bitmap
        ' Implementation here
        Return grayscale
    End Function

    Private Shared Function Binarize(enhanced As Bitmap, threshold As Integer) As Bitmap
        ' Implementation here
        Return enhanced
    End Function

    Private Shared Function RemoveNoise(binarized As Bitmap) As Bitmap
        ' Implementation here
        Return binarized
    End Function

    Private Shared Function Deskew(denoised As Bitmap) As Bitmap
        ' Implementation here
        Return denoised
    End Function

    Private Shared Function ScaleToDpi(deskewed As Bitmap, dpi As Integer) As Bitmap
        ' Implementation here
        Return deskewed
    End Function

    Private Shared Function RunTesseract(scaled As Bitmap) As String
        ' Implementation here
        Return "Processed Text"
    End Function
End Class

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%.

Szczegółowe porównanie funkcji

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

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

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

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.

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

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

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.

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

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

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.

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.

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.