发票 OCR API（开发者教程）

using IronOcr;
using System;

// Initialize a new instance of the IronTesseract class
// This is the main OCR engine that will process our invoice
var ocr = new IronTesseract();

// Configure OCR settings for better invoice processing
ocr.Configuration.BlackListCharacters = "~`$#^*_}{]___PROTECTED_LINK_48___ method from ___PROTECTED_LINK_49___ class. Key enhancements include:

- **Image preprocessing**: ___PROTECTED_LINK_50___ corrects tilted scans; ___PROTECTED_LINK_51___ removes artifacts
- **Resolution enhancement**: Setting ___PROTECTED_LINK_52___ improves recognition
- **Character blacklisting**: Prevents common OCR misinterpretations
- **Confidence scoring**: Assesses extraction reliability

!___PROTECTED_LINK_53___
**Invoice Parser**

<h3>How Do I Handle Different Invoice Formats?</h3>

Invoice formats vary between vendors, but IronOCR provides flexible solutions:

1. **Template-based**: Define ___PROTECTED_LINK_54___
2. **Computer vision**: Use ___PROTECTED_LINK_55___ to locate text
3. **Table extraction**: Leverage ___PROTECTED_LINK_56___ for line items
4. **Multi-format**: Process ___PROTECTED_LINK_57___, ___PROTECTED_LINK_58___, and ___PROTECTED_LINK_59___

For complex layouts, implement the ___PROTECTED_LINK_60___ which uses machine learning to identify structures automatically.

<h3>What Are Common Extraction Patterns for Invoice Data?</h3>

Invoice data follows recognizable patterns extractable using regular expressions with OCR results:

```csharp
using IronOcr;
using System;
using System.Text.`RegularExpressions`;
using System.Collections.Generic;

public class `InvoiceDataExtractor`
{
    private readonly `IronTesseract` ocr;

    public `InvoiceDataExtractor`()
    {
        ocr = new `IronTesseract`();
        // Configure for optimal invoice reading
        `ocr.Configuration`.`ReadBarcodes` = true; // Many invoices include barcodes
        `ocr.Configuration`.`TesseractVersion` = `TesseractVersion`.Tesseract5;
    }

    public `InvoiceData` `ExtractInvoiceData`(string imagePath)
    {
        var invoiceData = new `InvoiceData`();

        using (var input = new `OcrInput`(imagePath))
        {
            // Apply filters for better accuracy
            input.`EnhanceResolution`(300);
            `input.Sharpen`();

            var result = `ocr.Read`(input);
            var text = `result.Text`;

            // Extract invoice number
            invoiceData.`InvoiceNumber` = `ExtractPattern`(text, 
                @"INV[/-]?\d{4}[/-]?\d{5}|Invoice\s*#?\s*:?\s*(\d+)");

            // Extract dates
            invoiceData.`InvoiceDate` = `ExtractDate`(text, 
                @"Invoice\s*Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})");
            invoiceData.`DueDate` = `ExtractDate`(text, 
                @"Due\s*Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})");

            // Extract amounts
            `invoiceData.Total` = `ExtractAmount`(text, 
                @"Total\s*:?\s*\$?\s*([\d,]+\.?\d*)");
            `invoiceData.Tax` = `ExtractAmount`(text, 
                @"Tax\s*:?\s*\$?\s*([\d,]+\.?\d*)");

            // Extract vendor information
            invoiceData.`VendorName` = `ExtractVendorName`(text);

            // Extract line items using table detection
            invoiceData.`LineItems` = `ExtractLineItems`(result);

            // Extract any barcodes found
            if (`result.Barcodes`.Length > 0)
            {
                invoiceData.`BarcodeValues` = new List<string>();
                foreach (var barcode in `result.Barcodes`)
                {
                    invoiceData.`BarcodeValues`.Add(`barcode.Value`);
                }
            }
        }

        return invoiceData;
    }

    private string `ExtractPattern`(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, `RegexOptions`.`IgnoreCase`);
        return `match.Success` ? `match.Value` : `string.Empty`;
    }

    private `DateTime`? `ExtractDate`(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, `RegexOptions`.`IgnoreCase`);
        if (`match.Success` && `match.Groups`.Count > 1)
        {
            if (`DateTime`.`TryParse`(`match.Groups`[1].Value, out `DateTime` date))
                return date;
        }
        return null;
    }

    private decimal `ExtractAmount`(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, `RegexOptions`.`IgnoreCase`);
        if (`match.Success` && `match.Groups`.Count > 1)
        {
            var amountStr = `match.Groups`[1].Value.Replace(",", "");
            if (decimal.`TryParse`(amountStr, out decimal amount))
                return amount;
        }
        return 0;
    }

    private string `ExtractVendorName`(string text)
    {
        // Usually the vendor name appears in the first few lines
        var lines = `text.Split`('\n');
        if (`lines.Length` > 0)
        {
            // Simple heuristic: first non-empty line that's not a common header
            foreach (var line in lines)
            {
                var trimmed = `line.Trim`();
                if (!string.`IsNullOrEmpty`(trimmed) && 
                    !trimmed.`ToLower`().Contains("invoice") &&
                    `trimmed.Length` > 3)
                {
                    return trimmed;
                }
            }
        }
        return `string.Empty`;
    }

    private List<`LineItem`> `ExtractLineItems`(`OcrResult` result)
    {
        var lineItems = new List<`LineItem`>();

        // Use IronOCR's table detection capabilities
        if (`result.Tables` != null && `result.Tables`.Count > 0)
        {
            foreach (var table in `result.Tables`)
            {
                // Process each row as a potential line item
                for (int i = 1; i < table.`RowCount`; i++) // Skip header row
                {
                    var item = new `LineItem`
                    {
                        Description = table[i, 0]?.Text ?? "",
                        Quantity = `ParseQuantity`(table[i, 1]?.Text),
                        `UnitPrice` = `ParseAmount`(table[i, 2]?.Text),
                        Total = `ParseAmount`(table[i, 3]?.Text)
                    };

                    if (!string.`IsNullOrEmpty`(`item.Description`))
                        `lineItems.Add`(item);
                }
            }
        }

        return lineItems;
    }

    private int `ParseQuantity`(string text)
    {
        if (string.`IsNullOrEmpty`(text)) return 0;
        var cleaned = Regex.Replace(text, @"[^\d]", "");
        return int.`TryParse`(cleaned, out int qty) ? qty : 0;
    }

    private decimal `ParseAmount`(string text)
    {
        if (string.`IsNullOrEmpty`(text)) return 0;
        var cleaned = Regex.Replace(text, @"[^\d.]", "");
        return decimal.`TryParse`(cleaned, out decimal amt) ? amt : 0;
    }
}

// Data classes for structured invoice information
public class `InvoiceData`
{
    public string `InvoiceNumber` { get; set; }
    public `DateTime`? `InvoiceDate` { get; set; }
    public `DateTime`? `DueDate` { get; set; }
    public string `VendorName` { get; set; }
    public decimal Total { get; set; }
    public decimal Tax { get; set; }
    public List<`LineItem`> `LineItems` { get; set; }
    public List<string> `BarcodeValues` { get; set; }
}

public class `LineItem`
{
    public string Description { get; set; }
    public int Quantity { get; set; }
    public decimal `UnitPrice` { get; set; }
    public decimal Total { get; set; }
}

Imports IronOcr
Imports System
Imports System.Text.RegularExpressions
Imports System.Collections.Generic

Public Class InvoiceDataExtractor
    Private ReadOnly ocr As IronTesseract

    Public Sub New()
        ocr = New IronTesseract()
        ' Configure for optimal invoice reading
        ocr.Configuration.ReadBarcodes = True ' Many invoices include barcodes
        ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5
    End Sub

    Public Function ExtractInvoiceData(imagePath As String) As InvoiceData
        Dim invoiceData As New InvoiceData()

        Using input As New OcrInput(imagePath)
            ' Apply filters for better accuracy
            input.EnhanceResolution(300)
            input.Sharpen()

            Dim result = ocr.Read(input)
            Dim text = result.Text

            ' Extract invoice number
            invoiceData.InvoiceNumber = ExtractPattern(text, "INV[/-]?\d{4}[/-]?\d{5}|Invoice\s*#?\s*:?\s*(\d+)")

            ' Extract dates
            invoiceData.InvoiceDate = ExtractDate(text, "Invoice\s*Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})")
            invoiceData.DueDate = ExtractDate(text, "Due\s*Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})")

            ' Extract amounts
            invoiceData.Total = ExtractAmount(text, "Total\s*:?\s*\$?\s*([\d,]+\.?\d*)")
            invoiceData.Tax = ExtractAmount(text, "Tax\s*:?\s*\$?\s*([\d,]+\.?\d*)")

            ' Extract vendor information
            invoiceData.VendorName = ExtractVendorName(text)

            ' Extract line items using table detection
            invoiceData.LineItems = ExtractLineItems(result)

            ' Extract any barcodes found
            If result.Barcodes.Length > 0 Then
                invoiceData.BarcodeValues = New List(Of String)()
                For Each barcode In result.Barcodes
                    invoiceData.BarcodeValues.Add(barcode.Value)
                Next
            End If
        End Using

        Return invoiceData
    End Function

    Private Function ExtractPattern(text As String, pattern As String) As String
        Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
        Return If(match.Success, match.Value, String.Empty)
    End Function

    Private Function ExtractDate(text As String, pattern As String) As DateTime?
        Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
        If match.Success AndAlso match.Groups.Count > 1 Then
            Dim dateValue As DateTime
            If DateTime.TryParse(match.Groups(1).Value, dateValue) Then
                Return dateValue
            End If
        End If
        Return Nothing
    End Function

    Private Function ExtractAmount(text As String, pattern As String) As Decimal
        Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
        If match.Success AndAlso match.Groups.Count > 1 Then
            Dim amountStr = match.Groups(1).Value.Replace(",", "")
            Dim amount As Decimal
            If Decimal.TryParse(amountStr, amount) Then
                Return amount
            End If
        End If
        Return 0
    End Function

    Private Function ExtractVendorName(text As String) As String
        ' Usually the vendor name appears in the first few lines
        Dim lines = text.Split(ControlChars.Lf)
        If lines.Length > 0 Then
            ' Simple heuristic: first non-empty line that's not a common header
            For Each line In lines
                Dim trimmed = line.Trim()
                If Not String.IsNullOrEmpty(trimmed) AndAlso
                   Not trimmed.ToLower().Contains("invoice") AndAlso
                   trimmed.Length > 3 Then
                    Return trimmed
                End If
            Next
        End If
        Return String.Empty
    End Function

    Private Function ExtractLineItems(result As OcrResult) As List(Of LineItem)
        Dim lineItems As New List(Of LineItem)()

        ' Use IronOCR's table detection capabilities
        If result.Tables IsNot Nothing AndAlso result.Tables.Count > 0 Then
            For Each table In result.Tables
                ' Process each row as a potential line item
                For i As Integer = 1 To table.RowCount - 1 ' Skip header row
                    Dim item As New LineItem With {
                        .Description = If(table(i, 0)?.Text, ""),
                        .Quantity = ParseQuantity(table(i, 1)?.Text),
                        .UnitPrice = ParseAmount(table(i, 2)?.Text),
                        .Total = ParseAmount(table(i, 3)?.Text)
                    }

                    If Not String.IsNullOrEmpty(item.Description) Then
                        lineItems.Add(item)
                    End If
                Next
            Next
        End If

        Return lineItems
    End Function

    Private Function ParseQuantity(text As String) As Integer
        If String.IsNullOrEmpty(text) Then Return 0
        Dim cleaned = Regex.Replace(text, "[^\d]", "")
        Dim qty As Integer
        Return If(Integer.TryParse(cleaned, qty), qty, 0)
    End Function

    Private Function ParseAmount(text As String) As Decimal
        If String.IsNullOrEmpty(text) Then Return 0
        Dim cleaned = Regex.Replace(text, "[^\d.]", "")
        Dim amt As Decimal
        Return If(Decimal.TryParse(cleaned, amt), amt, 0)
    End Function
End Class

' Data classes for structured invoice information
Public Class InvoiceData
    Public Property InvoiceNumber As String
    Public Property InvoiceDate As DateTime?
    Public Property DueDate As DateTime?
    Public Property VendorName As String
    Public Property Total As Decimal
    Public Property Tax As Decimal
    Public Property LineItems As List(Of LineItem)
    Public Property BarcodeValues As List(Of String)
End Class

Public Class LineItem
    Public Property Description As String
    Public Property Quantity As Integer
    Public Property UnitPrice As Decimal
    Public Property Total As Decimal
End Class