适用于 Windows 10 的最佳 OCR 软件：面向开发者的对比评测

// TesseractOCR: basic usage — the API starts and ends here for most scenarios
using TesseractOCR;

public class TesseractOcrExample
{
    public string ExtractText(string imagePath)
    {
        // tessdata folder must exist and contain eng.traineddata
        using var engine = new Engine(@"./tessdata", Language.English);
        using var img = Pix.Image.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        return page.Text; // plain string, no structure
    }
}

Imports TesseractOCR

Public Class TesseractOcrExample
    Public Function ExtractText(imagePath As String) As String
        ' tessdata folder must exist and contain eng.traineddata
        Using engine = New Engine("./tessdata", Language.English)
            Using img = Pix.Image.LoadFromFile(imagePath)
                Using page = engine.Process(img)
                    Return page.Text ' plain string, no structure
                End Using
            End Using
        End Using
    End Function
End Class

// TesseractOCR: full extent of the core API
using TesseractOCR;

public class TesseractWrapperService
{
    private const string TessDataPath = @"./tessdata";

    // Text extraction — the primary use case
    public string BasicOcr(string imagePath)
    {
        using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
        using var img = Pix.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        return page.GetText();
    }

    // Confidence score — aggregate only, no word-level data
    public (string Text, float Confidence) OcrWithConfidence(string imagePath)
    {
        using var engine = new TesseractEngine(TessDataPath, "eng", EngineMode.Default);
        using var img = Pix.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        return (page.GetText(), page.GetMeanConfidence());
    }

    // 多语言 — requires manually downloaded traineddata files
    public string MultiLanguageOcr(string imagePath)
    {
        // fra.traineddata and deu.traineddata must exist in ./tessdata/
        using var engine = new TesseractEngine(TessDataPath, "eng+fra+deu", EngineMode.Default);
        using var img = Pix.LoadFromFile(imagePath);
        using var page = engine.Process(img);

        return page.GetText();
    }
}

Imports TesseractOCR

Public Class TesseractWrapperService
    Private Const TessDataPath As String = "./tessdata"

    ' Text extraction — the primary use case
    Public Function BasicOcr(imagePath As String) As String
        Using engine = New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            Using img = Pix.LoadFromFile(imagePath)
                Using page = engine.Process(img)
                    Return page.GetText()
                End Using
            End Using
        End Using
    End Function

    ' Confidence score — aggregate only, no word-level data
    Public Function OcrWithConfidence(imagePath As String) As (Text As String, Confidence As Single)
        Using engine = New TesseractEngine(TessDataPath, "eng", EngineMode.Default)
            Using img = Pix.LoadFromFile(imagePath)
                Using page = engine.Process(img)
                    Return (page.GetText(), page.GetMeanConfidence())
                End Using
            End Using
        End Using
    End Function

    ' 多语言 — requires manually downloaded traineddata files
    Public Function MultiLanguageOcr(imagePath As String) As String
        ' fra.traineddata and deu.traineddata must exist in ./tessdata/
        Using engine = New TesseractEngine(TessDataPath, "eng+fra+deu", EngineMode.Default)
            Using img = Pix.LoadFromFile(imagePath)
                Using page = engine.Process(img)
                    Return page.GetText()
                End Using
            End Using
        End Using
    End Function
End Class

using IronOcr;

public class IronOcrService
{
    // Text — one line
    public string BasicOcr(string imagePath)
    {
        return new IronTesseract().Read(imagePath).Text;
    }

    // Confidence — built into the result object
    public (string Text, double Confidence) OcrWithConfidence(string imagePath)
    {
        var result = new IronTesseract().Read(imagePath);
        return (result.Text, result.Confidence);
    }

    // Structured data — words with bounding boxes and per-word confidence
    public void StructuredExtraction(string imagePath)
    {
        var result = new IronTesseract().Read(imagePath);

        foreach (var page in result.Pages)
        {
            foreach (var line in result.Lines)
            {
                Console.WriteLine($"Line: {line.Text}");
            }
            foreach (var word in result.Words)
            {
                // Coordinates and confidence available per word
                Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) — {word.Confidence}%");
            }
        }
    }

    // 多语言 — NuGet packages, no filesystem management
    public string MultiLanguageOcr(string imagePath)
    {
        var ocr = new IronTesseract();
        ocr.Language = OcrLanguage.English;
        ocr.AddSecondaryLanguage(OcrLanguage.French);
        ocr.AddSecondaryLanguage(OcrLanguage.German);
        return ocr.Read(imagePath).Text;
    }
}

Imports IronOcr

Public Class IronOcrService
    ' Text — one line
    Public Function BasicOcr(imagePath As String) As String
        Return New IronTesseract().Read(imagePath).Text
    End Function

    ' Confidence — built into the result object
    Public Function OcrWithConfidence(imagePath As String) As (Text As String, Confidence As Double)
        Dim result = New IronTesseract().Read(imagePath)
        Return (result.Text, result.Confidence)
    End Function

    ' Structured data — words with bounding boxes and per-word confidence
    Public Sub StructuredExtraction(imagePath As String)
        Dim result = New IronTesseract().Read(imagePath)

        For Each page In result.Pages
            For Each line In result.Lines
                Console.WriteLine($"Line: {line.Text}")
            Next
            For Each word In result.Words
                ' Coordinates and confidence available per word
                Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) — {word.Confidence}%")
            Next
        Next
    End Sub

    ' 多语言 — NuGet packages, no filesystem management
    Public Function MultiLanguageOcr(imagePath As String) As String
        Dim ocr = New IronTesseract()
        ocr.Language = OcrLanguage.English
        ocr.AddSecondaryLanguage(OcrLanguage.French)
        ocr.AddSecondaryLanguage(OcrLanguage.German)
        Return ocr.Read(imagePath).Text
    End Function
End Class

// TesseractOCR: what failure looks like in practice
// Simplified — actual error behavior depends on Tesseract native binary version

public string OcrWithNoGuarantees(string imagePath)
{
    using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);
    using var img = Pix.LoadFromFile(imagePath);
    using var page = engine.Process(img);

    // On a degraded image or internal engine error:
    // page.GetText() may return "" with no exception
    // Caller has no way to distinguish "no text found" from "engine failed"
    return page.GetText();
}

Imports Tesseract

Public Function OcrWithNoGuarantees(imagePath As String) As String
    Using engine As New TesseractEngine("./tessdata", "eng", EngineMode.Default)
        Using img As Pix = Pix.LoadFromFile(imagePath)
            Using page As Page = engine.Process(img)
                ' On a degraded image or internal engine error:
                ' page.GetText() may return "" with no exception
                ' Caller has no way to distinguish "no text found" from "engine failed"
                Return page.GetText()
            End Using
        End Using
    End Using
End Function

using IronOcr;

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

            // Confidence below threshold is detectable — not a silent empty string
            if (result.Confidence < 20)
            {
                // Low confidence is signaled, not silently dropped
                throw new InvalidOperationException(
                    $"OCR confidence too low: {result.Confidence}%. Check image quality.");
            }

            return result.Text;
        }
        catch (IronOcrException ex)
        {
            // Engine-level failures are typed and catchable
            throw new ApplicationException($"OCR engine failure: {ex.Message}", ex);
        }
    }

    // Preprocessing before recognition reduces failure rates for poor-quality inputs
    public string OcrWithPreprocessing(string imagePath)
    {
        using var input = new OcrInput();
        input.LoadImage(imagePath);
        input.Deskew();
        输入.去噪();
        input.Contrast();

        return new IronTesseract().Read(input).Text;
    }
}

Imports IronOcr

Public Class ReliableOcrService
    Public Function OcrWithErrorHandling(imagePath As String) As String
        Try
            Dim result = New IronTesseract().Read(imagePath)

            ' Confidence below threshold is detectable — not a silent empty string
            If result.Confidence < 20 Then
                ' Low confidence is signaled, not silently dropped
                Throw New InvalidOperationException($"OCR confidence too low: {result.Confidence}%. Check image quality.")
            End If

            Return result.Text
        Catch ex As IronOcrException
            ' Engine-level failures are typed and catchable
            Throw New ApplicationException($"OCR engine failure: {ex.Message}", ex)
        End Try
    End Function

    ' Preprocessing before recognition reduces failure rates for poor-quality inputs
    Public Function OcrWithPreprocessing(imagePath As String) As String
        Using input As New OcrInput()
            input.LoadImage(imagePath)
            input.Deskew()
            input.Denoise()
            input.Contrast()

            Return New IronTesseract().Read(input).Text
        End Using
    End Function
End Class

// TesseractOCR: output capabilities — directly from source
public class TesseractLimitations
{
    public void ShowLimitations()
    {
        Console.WriteLine("Tesseract Wrapper Limitations:");
        Console.WriteLine("1. 不支持 PDF - need separate library");
        Console.WriteLine("2. 否 preprocessing - must implement yourself");
        Console.WriteLine("3. 否 barcode reading");
        Console.WriteLine("4. 否 searchable PDF output");
        Console.WriteLine("5. tessdata management required");
        Console.WriteLine("6. Platform binaries must match");
    }
}

Public Class TesseractLimitations
    Public Sub ShowLimitations()
        Console.WriteLine("Tesseract Wrapper Limitations:")
        Console.WriteLine("1. 不支持 PDF - need separate library")
        Console.WriteLine("2. 否 preprocessing - must implement yourself")
        Console.WriteLine("3. 否 barcode reading")
        Console.WriteLine("4. 否 searchable PDF output")
        Console.WriteLine("5. tessdata management required")
        Console.WriteLine("6. Platform binaries must match")
    End Sub
End Class

using IronOcr;

public class OutputFormatExamples
{
    public void AllOutputFormats(string inputPath)
    {
        var result = new IronTesseract().Read(inputPath);

        // Plain text
        string text = result.Text;

        // 可搜索的PDF — scanned document becomes full-text searchable
        result.SaveAsSearchablePdf("searchable-output.pdf");

        // hOCR — HTML with word positions for accessibility pipelines
        result.SaveAsHocrFile("output.hocr");

        // Structured word data — positions for data extraction
        foreach (var word in result.Words)
        {
            Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y},{word.Width},{word.Height})");
        }
    }

    // Scanned PDF in, searchable PDF out — two lines total
    public void MakeSearchable(string scannedPdfPath, string outputPath)
    {
        var result = new IronTesseract().Read(scannedPdfPath);
        result.SaveAsSearchablePdf(outputPath);
    }
}

Imports IronOcr

Public Class OutputFormatExamples
    Public Sub AllOutputFormats(inputPath As String)
        Dim result = New IronTesseract().Read(inputPath)

        ' Plain text
        Dim text As String = result.Text

        ' 可搜索的PDF — scanned document becomes full-text searchable
        result.SaveAsSearchablePdf("searchable-output.pdf")

        ' hOCR — HTML with word positions for accessibility pipelines
        result.SaveAsHocrFile("output.hocr")

        ' Structured word data — positions for data extraction
        For Each word In result.Words
            Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y},{word.Width},{word.Height})")
        Next
    End Sub

    ' Scanned PDF in, searchable PDF out — two lines total
    Public Sub MakeSearchable(scannedPdfPath As String, outputPath As String)
        Dim result = New IronTesseract().Read(scannedPdfPath)
        result.SaveAsSearchablePdf(outputPath)
    End Sub
End Class

// TesseractOCR: tessdata path required at every engine instantiation
using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);

// IronOCR: no tessdata path — language resolved from NuGet package
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.English;

Imports Tesseract
Imports IronOcr

' TesseractOCR: tessdata path required at every engine instantiation
Using engine As New TesseractEngine("./tessdata", "eng", EngineMode.Default)
    ' Engine usage code goes here
End Using

' IronOCR: no tessdata path — language resolved from NuGet package
Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.English

// IronOCR: per-word confidence for field-level quality routing
var result = new IronTesseract().Read("invoice.jpg");

var lowConfidenceWords = result.Words
    .Where(w => w.Confidence < 60)
    .Select(w => w.Text)
    .ToList();

if (lowConfidenceWords.Any())
{
    // Flag document for human review — specific words are uncertain
    Console.WriteLine($"Low confidence fields: {string.Join(", ", lowConfidenceWords)}");
}

Imports IronOcr

' IronOCR: per-word confidence for field-level quality routing
Dim result = New IronTesseract().Read("invoice.jpg")

Dim lowConfidenceWords = result.Words _
    .Where(Function(w) w.Confidence < 60) _
    .Select(Function(w) w.Text) _
    .ToList()

If lowConfidenceWords.Any() Then
    ' Flag document for human review — specific words are uncertain
    Console.WriteLine($"Low confidence fields: {String.Join(", ", lowConfidenceWords)}")
End If