Tesseract vs Microsoft OCR: Porównanie bezpośrednie

Wzorzec analizy faktur Mindee

Proces wyodrębniania faktur wMindeejest prosty, gdy dopuszczalna jest transmisja w chmurze:

using Mindee;
using Mindee.Input;
using Mindee.Product.Invoice;

public class MindeeInvoiceService
{
    private readonly MindeeClient _client;

    public MindeeInvoiceService(string apiKey)
    {
        // API key authenticates withMindeecloud
        _client = new MindeeClient(apiKey);
    }

    public async Task<InvoiceData> ParseInvoiceAsync(string filePath)
    {
        // Document leaves your infrastructure at this line
        var inputSource = new LocalInputSource(filePath);

        // Full document transmitted toMindee— bank details, tax IDs, line items
        var response = await _client.ParseAsync<InvoiceV4>(inputSource);

        var prediction = response.Document.Inference.Prediction;

        return new InvoiceData
        {
            InvoiceNumber = prediction.InvoiceNumber?.Value,
            Date          = prediction.InvoiceDate?.Value,
            VendorName    = prediction.SupplierName?.Value,
            CustomerName  = prediction.CustomerName?.Value,
            Total         = prediction.TotalAmount?.Value,
            // Payment details transmitted toMindeecloud
            PaymentDetails = prediction.SupplierPaymentDetails?
                .Select(pd => new PaymentDetail
                {
                    Iban          = pd.Iban,
                    Swift         = pd.Swift,
                    RoutingNumber = pd.RoutingNumber,
                    AccountNumber = pd.AccountNumber
                }).ToList()
        };
    }
}

using Mindee;
using Mindee.Input;
using Mindee.Product.Invoice;

public class MindeeInvoiceService
{
    private readonly MindeeClient _client;

    public MindeeInvoiceService(string apiKey)
    {
        // API key authenticates withMindeecloud
        _client = new MindeeClient(apiKey);
    }

    public async Task<InvoiceData> ParseInvoiceAsync(string filePath)
    {
        // Document leaves your infrastructure at this line
        var inputSource = new LocalInputSource(filePath);

        // Full document transmitted toMindee— bank details, tax IDs, line items
        var response = await _client.ParseAsync<InvoiceV4>(inputSource);

        var prediction = response.Document.Inference.Prediction;

        return new InvoiceData
        {
            InvoiceNumber = prediction.InvoiceNumber?.Value,
            Date          = prediction.InvoiceDate?.Value,
            VendorName    = prediction.SupplierName?.Value,
            CustomerName  = prediction.CustomerName?.Value,
            Total         = prediction.TotalAmount?.Value,
            // Payment details transmitted toMindeecloud
            PaymentDetails = prediction.SupplierPaymentDetails?
                .Select(pd => new PaymentDetail
                {
                    Iban          = pd.Iban,
                    Swift         = pd.Swift,
                    RoutingNumber = pd.RoutingNumber,
                    AccountNumber = pd.AccountNumber
                }).ToList()
        };
    }
}

Imports Mindee
Imports Mindee.Input
Imports Mindee.Product.Invoice
Imports System.Threading.Tasks

Public Class MindeeInvoiceService
    Private ReadOnly _client As MindeeClient

    Public Sub New(apiKey As String)
        ' API key authenticates with Mindee cloud
        _client = New MindeeClient(apiKey)
    End Sub

    Public Async Function ParseInvoiceAsync(filePath As String) As Task(Of InvoiceData)
        ' Document leaves your infrastructure at this line
        Dim inputSource = New LocalInputSource(filePath)

        ' Full document transmitted to Mindee— bank details, tax IDs, line items
        Dim response = Await _client.ParseAsync(Of InvoiceV4)(inputSource)

        Dim prediction = response.Document.Inference.Prediction

        Return New InvoiceData With {
            .InvoiceNumber = prediction.InvoiceNumber?.Value,
            .Date = prediction.InvoiceDate?.Value,
            .VendorName = prediction.SupplierName?.Value,
            .CustomerName = prediction.CustomerName?.Value,
            .Total = prediction.TotalAmount?.Value,
            ' Payment details transmitted to Mindee cloud
            .PaymentDetails = prediction.SupplierPaymentDetails?.
                Select(Function(pd) New PaymentDetail With {
                    .Iban = pd.Iban,
                    .Swift = pd.Swift,
                    .RoutingNumber = pd.RoutingNumber,
                    .AccountNumber = pd.AccountNumber
                }).ToList()
        }
    End Function
End Class

Kod jest zwięzły. Kompromisem jest to, że pd.Iban, pd.RoutingNumber i pd.AccountNumber istnieją w odpowiedzi tylko dlatego, żeMindeeotrzymało i przetworzyło dokument je zawierający.

Szczegółowe porównanie funkcji

Podejście Mindee

Kiedy Twoja aplikacja wywołuje _client.ParseAsync<InvoiceV4>(inputSource), cały plik dokumentu jest przesyłany do infrastruktury chmurowej Mindee. Nie są to metadane ani odcisk palca — jest to pełna treść dokumentu. Pola, któreMindeepobiera z faktur, należą do najbardziej wrażliwych danych, z jakimi ma do czynienia Twoja organizacja:

// Every field in this response existed becauseMindeereceived your document
var prediction = response.Document.Inference.Prediction;

// Financial identifiers — transmitted toMindeecloud
var iban          = prediction.SupplierPaymentDetails?.FirstOrDefault()?.Iban;
var routingNumber = prediction.SupplierPaymentDetails?.FirstOrDefault()?.RoutingNumber;
var accountNumber = prediction.SupplierPaymentDetails?.FirstOrDefault()?.AccountNumber;
var swift         = prediction.SupplierPaymentDetails?.FirstOrDefault()?.Swift;

// Tax identification — transmitted toMindeecloud
var vendorTaxId   = prediction.SupplierCompanyRegistrations?.FirstOrDefault()?.Value;
var customerReg   = prediction.CustomerCompanyRegistrations?.FirstOrDefault()?.Value;

// Business intelligence — transmitted toMindeecloud
var lineItems = prediction.LineItems?
    .Select(li => new
    {
        li.Description,  // What you buy
        li.Quantity,     // How much you buy
        li.UnitPrice,    // What you pay per unit
        li.TotalAmount   // Line total
    }).ToList();

// Every field in this response existed becauseMindeereceived your document
var prediction = response.Document.Inference.Prediction;

// Financial identifiers — transmitted toMindeecloud
var iban          = prediction.SupplierPaymentDetails?.FirstOrDefault()?.Iban;
var routingNumber = prediction.SupplierPaymentDetails?.FirstOrDefault()?.RoutingNumber;
var accountNumber = prediction.SupplierPaymentDetails?.FirstOrDefault()?.AccountNumber;
var swift         = prediction.SupplierPaymentDetails?.FirstOrDefault()?.Swift;

// Tax identification — transmitted toMindeecloud
var vendorTaxId   = prediction.SupplierCompanyRegistrations?.FirstOrDefault()?.Value;
var customerReg   = prediction.CustomerCompanyRegistrations?.FirstOrDefault()?.Value;

// Business intelligence — transmitted toMindeecloud
var lineItems = prediction.LineItems?
    .Select(li => new
    {
        li.Description,  // What you buy
        li.Quantity,     // How much you buy
        li.UnitPrice,    // What you pay per unit
        li.TotalAmount   // Line total
    }).ToList();

' Every field in this response existed because Mindee received your document
Dim prediction = response.Document.Inference.Prediction

' Financial identifiers — transmitted to Mindee cloud
Dim iban = prediction.SupplierPaymentDetails?.FirstOrDefault()?.Iban
Dim routingNumber = prediction.SupplierPaymentDetails?.FirstOrDefault()?.RoutingNumber
Dim accountNumber = prediction.SupplierPaymentDetails?.FirstOrDefault()?.AccountNumber
Dim swift = prediction.SupplierPaymentDetails?.FirstOrDefault()?.Swift

' Tax identification — transmitted to Mindee cloud
Dim vendorTaxId = prediction.SupplierCompanyRegistrations?.FirstOrDefault()?.Value
Dim customerReg = prediction.CustomerCompanyRegistrations?.FirstOrDefault()?.Value

' Business intelligence — transmitted to Mindee cloud
Dim lineItems = prediction.LineItems?.
    Select(Function(li) New With {
        li.Description,  ' What you buy
        li.Quantity,     ' How much you buy
        li.UnitPrice,    ' What you pay per unit
        li.TotalAmount   ' Line total
    }).ToList()

Mindee posiada certyfikat SOC 2 typu II i deklaruje zgodność z RODO. Dokumentacja zgodności potwierdza, że firmaMindeeprzestrzega zasad bezpieczeństwa. Nie oznacza to, że dane pozostają w obrębie strefy bezpieczeństwa. Dokument fizycznie opuszcza infrastrukturę użytkownika, przechodzi przez publiczny internet i jest przetwarzany na sprzęcie, którego użytkownik nie posiada ani nie kontroluje. W przypadku planu bezpłatnego dokumenty są przechowywane przez maksymalnie 30 dni.

Problem ma charakter strukturalny. Jeśli Twój przypadek użycia obejmuje przetwarzanie faktur przesłanych przez klientów, przekazujesz relacje klientów z dostawcami, dane bankowe i wzorce zakupowe stronom trzecim. Jeśli działasz zgodnie z przepisami GLBA, HIPAA, CMMC, FedRAMP lub przepisami dotyczącymi lokalizacji danych, przetwarzanie dokumentów w chmurze za pośrednictwem API stron trzecich wymaga wyraźnych umów z podmiotami przetwarzającymi dane i może być całkowicie zabronione.

Podejście IronOCR

IronOCR przetwarza dokumenty bez konieczności przesyłania ich na zewnątrz. Silnik OCR, modele językowe i proces przetwarzania wstępnego działają w ramach procesu na sprzęcie użytkownika. W momencie rozpoznawania nie jest wykonywane żadne wywołanie sieciowe:

using IronOcr;
using System.Text.RegularExpressions;

public class LocalInvoiceExtractor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public InvoiceData ExtractInvoice(string filePath)
    {
        // Processing on your machine — no data transmission occurs
        var result = _ocr.Read(filePath);
        var text   = result.Text;

        return new InvoiceData
        {
            InvoiceNumber = ExtractPattern(text, @"Invoice\s*#?\s*:?\s*([A-Z0-9]+-?\d+)"),
            Date          = ExtractDate(text),
            VendorName    = ExtractVendorName(result),
            CustomerName  = ExtractCustomerName(text),
            Total         = ExtractAmount(text, @"Total\s*(?:Due)?\s*:?\s*\$?([\d,]+\.?\d*)"),
            Tax           = ExtractAmount(text, @"Tax\s*:?\s*\$?([\d,]+\.?\d*)")
        };
    }

    private string ExtractVendorName(OcrResult result)
    {
        // Vendor name typically appears in the top 15% of the invoice
        var maxY     = result.Lines.Max(l => l.Y + l.Height);
        var topLines = result.Lines
            .Where(l => l.Y < maxY * 0.15)
            .OrderBy(l => l.Y);
        return topLines.FirstOrDefault(l => l.Text.Length > 5)?.Text;
    }

    private string ExtractPattern(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
        return match.Success ? match.Groups[1].Value : null;
    }
}

using IronOcr;
using System.Text.RegularExpressions;

public class LocalInvoiceExtractor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public InvoiceData ExtractInvoice(string filePath)
    {
        // Processing on your machine — no data transmission occurs
        var result = _ocr.Read(filePath);
        var text   = result.Text;

        return new InvoiceData
        {
            InvoiceNumber = ExtractPattern(text, @"Invoice\s*#?\s*:?\s*([A-Z0-9]+-?\d+)"),
            Date          = ExtractDate(text),
            VendorName    = ExtractVendorName(result),
            CustomerName  = ExtractCustomerName(text),
            Total         = ExtractAmount(text, @"Total\s*(?:Due)?\s*:?\s*\$?([\d,]+\.?\d*)"),
            Tax           = ExtractAmount(text, @"Tax\s*:?\s*\$?([\d,]+\.?\d*)")
        };
    }

    private string ExtractVendorName(OcrResult result)
    {
        // Vendor name typically appears in the top 15% of the invoice
        var maxY     = result.Lines.Max(l => l.Y + l.Height);
        var topLines = result.Lines
            .Where(l => l.Y < maxY * 0.15)
            .OrderBy(l => l.Y);
        return topLines.FirstOrDefault(l => l.Text.Length > 5)?.Text;
    }

    private string ExtractPattern(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
        return match.Success ? match.Groups[1].Value : null;
    }
}

Imports IronOcr
Imports System.Text.RegularExpressions

Public Class LocalInvoiceExtractor
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractInvoice(filePath As String) As InvoiceData
        ' Processing on your machine — no data transmission occurs
        Dim result = _ocr.Read(filePath)
        Dim text = result.Text

        Return New InvoiceData With {
            .InvoiceNumber = ExtractPattern(text, "Invoice\s*#?\s*:?\s*([A-Z0-9]+-?\d+)"),
            .Date = ExtractDate(text),
            .VendorName = ExtractVendorName(result),
            .CustomerName = ExtractCustomerName(text),
            .Total = ExtractAmount(text, "Total\s*(?:Due)?\s*:?\s*\$?([\d,]+\.?\d*)"),
            .Tax = ExtractAmount(text, "Tax\s*:?\s*\$?([\d,]+\.?\d*)")
        }
    End Function

    Private Function ExtractVendorName(result As OcrResult) As String
        ' Vendor name typically appears in the top 15% of the invoice
        Dim maxY = result.Lines.Max(Function(l) l.Y + l.Height)
        Dim topLines = result.Lines _
            .Where(Function(l) l.Y < maxY * 0.15) _
            .OrderBy(Function(l) l.Y)
        Return topLines.FirstOrDefault(Function(l) l.Text.Length > 5)?.Text
    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.Groups(1).Value, Nothing)
    End Function
End Class

Numery kont bankowych zawarte w dokumencie nigdy nie trafiają do żadnego systemu poza infrastrukturą użytkownika. Zakres zgodności obejmuje wyłącznie Państwa organizację. Samouczek dotyczący rozpoznawania faktur w IronOCR oraz przewodnik po skanowaniu paragonów szczegółowo omawiają gotowe do użycia wzorce ekstrakcji.

Kompromis jest jasny: wstępnie wyszkolone modeleMindeewyodrębniają pola strukturalne bez konieczności pisania wzorców przez użytkownika.IronOCR wymaga tworzenia i utrzymywania wzorców ekstrakcji. W przypadku większości formatów faktur napisanie tych szablonów zajmuje kilka godzin, a ich utrzymanie jest proste. Korzyść w postaci suwerenności danych ma charakter trwały.

Podejście Mindee

Typy dokumentów obsługiwane przezMindeesą ustalone na poziomie API. Wstępnie zbudowane API pokrywają InvoiceV4, ReceiptV5, PassportV1, UsDriverLicenseV1, BankAccountDetailsV2, FinancialDocumentV1, i małą liczbę innych. Jeśli Twoja aplikacja musi przetwarzać dokumenty spoza tej listy — umowy, formularze medyczne, etykiety wysyłkowe, umowy najmu, niestandardowe formularze biznesowe — dostępne opcje to szkolenie w zakresie modeli niestandardowych w ramach planu Enterprise firmyMindeelub znalezienie innego rozwiązania.

// These work withMindeepre-built APIs:
var invoiceResponse  = await _client.ParseAsync<InvoiceV4>(inputSource);
var receiptResponse  = await _client.ParseAsync<ReceiptV5>(inputSource);
var passportResponse = await _client.ParseAsync<PassportV1>(inputSource);

// These require custom training (Enterprise plan + labeling + lead time):
// client.ParseAsync<ContractV1>(inputSource);      // not available
// client.ParseAsync<MedicalFormV1>(inputSource);   // not available
// client.ParseAsync<ShippingLabelV1>(inputSource); // not available

// These work withMindeepre-built APIs:
var invoiceResponse  = await _client.ParseAsync<InvoiceV4>(inputSource);
var receiptResponse  = await _client.ParseAsync<ReceiptV5>(inputSource);
var passportResponse = await _client.ParseAsync<PassportV1>(inputSource);

// These require custom training (Enterprise plan + labeling + lead time):
// client.ParseAsync<ContractV1>(inputSource);      // not available
// client.ParseAsync<MedicalFormV1>(inputSource);   // not available
// client.ParseAsync<ShippingLabelV1>(inputSource); // not available

Szkolenie modelu niestandardowego wMindeewymaga przykładowych dokumentów, oznaczenia pól, czasu szkolenia oraz cennika Enterprise. Jeśli Twoje wymagania dotyczące przetwarzania dokumentów będą się z czasem rozszerzać, każdy nowy typ dokumentu będzie stanowił oddzielną inwestycję inżynieryjną, objętą procesem szkoleniowym Mindee.

Podejście IronOCR

IronOCR przetwarza dowolny typ dokumentu przy użyciu tego samego interfejsu API i tej samej instalacji. Logika ekstrakcji to oparty na wzorcach kod, który piszesz raz i który w całości należy do Ciebie:

using IronOcr;
using System.Text.RegularExpressions;

public class UniversalDocumentProcessor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    // Invoices — same approach asMindeecovers
    public InvoiceData ProcessInvoice(string file)
    {
        var result = _ocr.Read(file);
        return new InvoiceData
        {
            InvoiceNumber = ExtractPattern(result.Text, @"Invoice\s*#?\s*(\w+\d+)"),
            Total         = ExtractCurrency(result.Text, @"Total\s*:?\s*\$?([\d,]+\.?\d*)")
        };
    }

    // Umowy —Mindeehas no pre-built API for these
    public ContractData ProcessContract(string file)
    {
        var result = _ocr.Read(file);
        return new ContractData
        {
            PartyA         = ExtractPattern(result.Text, @"between\s+(.+?)\s+and"),
            PartyB         = ExtractPattern(result.Text, @"and\s+(.+?)\s*\("),
            EffectiveDate  = ExtractDate(result.Text, @"Effective\s+Date\s*:?\s*(.+)"),
            ContractValue  = ExtractCurrency(result.Text, @"Value\s*:?\s*\$?([\d,]+)")
        };
    }

    // Formularze medyczne —Mindeehas no pre-built API for these
    public MedicalFormData ProcessMedicalForm(string file)
    {
        var result = _ocr.Read(file);
        return new MedicalFormData
        {
            PatientName = ExtractPattern(result.Text, @"Patient\s*Name\s*:?\s*(.+)"),
            MRN         = ExtractPattern(result.Text, @"MRN\s*:?\s*(\w+)"),
            Diagnosis   = ExtractPattern(result.Text, @"Diagnosis\s*:?\s*(.+)")
        };
    }

    private string ExtractPattern(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
        return match.Success ? match.Groups[1].Value.Trim() : null;
    }

    private decimal? ExtractCurrency(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
        if (match.Success && decimal.TryParse(
            match.Groups[1].Value.Replace(",", ""), out var value))
            return value;
        return null;
    }

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

using IronOcr;
using System.Text.RegularExpressions;

public class UniversalDocumentProcessor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    // Invoices — same approach asMindeecovers
    public InvoiceData ProcessInvoice(string file)
    {
        var result = _ocr.Read(file);
        return new InvoiceData
        {
            InvoiceNumber = ExtractPattern(result.Text, @"Invoice\s*#?\s*(\w+\d+)"),
            Total         = ExtractCurrency(result.Text, @"Total\s*:?\s*\$?([\d,]+\.?\d*)")
        };
    }

    // Umowy —Mindeehas no pre-built API for these
    public ContractData ProcessContract(string file)
    {
        var result = _ocr.Read(file);
        return new ContractData
        {
            PartyA         = ExtractPattern(result.Text, @"between\s+(.+?)\s+and"),
            PartyB         = ExtractPattern(result.Text, @"and\s+(.+?)\s*\("),
            EffectiveDate  = ExtractDate(result.Text, @"Effective\s+Date\s*:?\s*(.+)"),
            ContractValue  = ExtractCurrency(result.Text, @"Value\s*:?\s*\$?([\d,]+)")
        };
    }

    // Formularze medyczne —Mindeehas no pre-built API for these
    public MedicalFormData ProcessMedicalForm(string file)
    {
        var result = _ocr.Read(file);
        return new MedicalFormData
        {
            PatientName = ExtractPattern(result.Text, @"Patient\s*Name\s*:?\s*(.+)"),
            MRN         = ExtractPattern(result.Text, @"MRN\s*:?\s*(\w+)"),
            Diagnosis   = ExtractPattern(result.Text, @"Diagnosis\s*:?\s*(.+)")
        };
    }

    private string ExtractPattern(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
        return match.Success ? match.Groups[1].Value.Trim() : null;
    }

    private decimal? ExtractCurrency(string text, string pattern)
    {
        var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
        if (match.Success && decimal.TryParse(
            match.Groups[1].Value.Replace(",", ""), out var value))
            return value;
        return null;
    }

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

Imports IronOcr
Imports System.Text.RegularExpressions

Public Class UniversalDocumentProcessor
    Private ReadOnly _ocr As New IronTesseract()

    ' Invoices — same approach asMindeecovers
    Public Function ProcessInvoice(file As String) As InvoiceData
        Dim result = _ocr.Read(file)
        Return New InvoiceData With {
            .InvoiceNumber = ExtractPattern(result.Text, "Invoice\s*#?\s*(\w+\d+)"),
            .Total = ExtractCurrency(result.Text, "Total\s*:?\s*\$?([\d,]+\.?\d*)")
        }
    End Function

    ' Umowy —Mindeehas no pre-built API for these
    Public Function ProcessContract(file As String) As ContractData
        Dim result = _ocr.Read(file)
        Return New ContractData With {
            .PartyA = ExtractPattern(result.Text, "between\s+(.+?)\s+and"),
            .PartyB = ExtractPattern(result.Text, "and\s+(.+?)\s*\("),
            .EffectiveDate = ExtractDate(result.Text, "Effective\s+Date\s*:?\s*(.+)"),
            .ContractValue = ExtractCurrency(result.Text, "Value\s*:?\s*\$?([\d,]+)")
        }
    End Function

    ' Formularze medyczne —Mindeehas no pre-built API for these
    Public Function ProcessMedicalForm(file As String) As MedicalFormData
        Dim result = _ocr.Read(file)
        Return New MedicalFormData With {
            .PatientName = ExtractPattern(result.Text, "Patient\s*Name\s*:?\s*(.+)"),
            .MRN = ExtractPattern(result.Text, "MRN\s*:?\s*(\w+)"),
            .Diagnosis = ExtractPattern(result.Text, "Diagnosis\s*:?\s*(.+)")
        }
    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.Groups(1).Value.Trim(), Nothing)
    End Function

    Private Function ExtractCurrency(text As String, pattern As String) As Decimal?
        Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
        If match.Success AndAlso Decimal.TryParse(match.Groups(1).Value.Replace(",", ""), value) Then
            Return value
        End If
        Return Nothing
    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 DateTime.TryParse(match.Groups(1).Value, dateValue) Then
            Return dateValue
        End If
        Return Nothing
    End Function
End Class

Gdy wymagany jest nowy typ dokumentu, dodanie go oznacza napisanie wzorców ekstrakcji — zazwyczaj zajmuje to kilka godzin pracy. Bez angażowania dostawców, bez szkoleń, bez dodatkowych kosztów. Samouczek dotyczący czytania konkretnych dokumentów oraz przewodnik po OCR opartym na regionach obejmują techniki ekstrakcji opartej na strefach w formularzach ustrukturyzowanych.

Podejście Mindee

CenyMindeesą ustalane na podstawie liczby stron i mają charakter stały. Skontaktuj się z Mindee, aby poznać aktualne stawki planów. Za strony wykraczające poza przydzielony limit naliczane są opłaty za nadwyżkę. W przypadku wielostronicowych plików PDF każda strona jest liczona osobno. Strony dotyczące rozwoju i testowania wliczają się do miesięcznego limitu.

Dla operacji rozliczenia kosztów około średniego rozmiaru, koszty na stronę składają się z czasem i skalują się z objętością. Szczytowe obciążenie pod koniec roku lub duża partia wielostronicowych faktur może bez ostrzeżenia spowodować przekroczenie kosztów przewidzianych w ramach danego pakietu.

Przetwarzanie wsadowe za pomocąMindeewymaga również zarządzania limitami szybkości. Każdy dokument stanowi osobne wywołanie API, a wywołania muszą być rozłożone w czasie, aby uniknąć ograniczeń przepustowości:

//Mindeebatch: each document is an API call with associated cost and rate limit
public async Task<List<InvoiceData>> ProcessBatchAsync(IEnumerable<string> files)
{
    var results = new List<InvoiceData>();

    foreach (var file in files)
    {
        var inputSource = new LocalInputSource(file);
        var response    = await _client.ParseAsync<InvoiceV4>(inputSource);
        results.Add(MapResult(response.Document.Inference.Prediction));

        // Rate limit compliance — required, not optional
        await Task.Delay(100);
    }

    return results;
}

//Mindeebatch: each document is an API call with associated cost and rate limit
public async Task<List<InvoiceData>> ProcessBatchAsync(IEnumerable<string> files)
{
    var results = new List<InvoiceData>();

    foreach (var file in files)
    {
        var inputSource = new LocalInputSource(file);
        var response    = await _client.ParseAsync<InvoiceV4>(inputSource);
        results.Add(MapResult(response.Document.Inference.Prediction));

        // Rate limit compliance — required, not optional
        await Task.Delay(100);
    }

    return results;
}

Imports System.Collections.Generic
Imports System.Threading.Tasks

' Mindeebatch: each document is an API call with associated cost and rate limit
Public Async Function ProcessBatchAsync(files As IEnumerable(Of String)) As Task(Of List(Of InvoiceData))
    Dim results As New List(Of InvoiceData)()

    For Each file In files
        Dim inputSource As New LocalInputSource(file)
        Dim response = Await _client.ParseAsync(Of InvoiceV4)(inputSource)
        results.Add(MapResult(response.Document.Inference.Prediction))

        ' Rate limit compliance — required, not optional
        Await Task.Delay(100)
    Next

    Return results
End Function

Podejście IronOCR

Licencja IronOCR jest wieczysta i nieograniczona pod względem ilości. Licencja $1,499 Plus pokrywa trzech deweloperów i trzy projekty bez opłat za dokument. Przetworzenie 3 000 faktur miesięcznie lub 300 000 miesięcznie nic nie kosztuje dodatkowo. Przetwarzanie wsadowe używa Parallel.ForEach bez obaw o limity:

using IronOcr;

public class IronOcrBatchProcessor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    // Nie rate limits, no per-document cost, no network latency
    public List<InvoiceData> ProcessBatch(IEnumerable<string> files)
    {
        var results = new List<InvoiceData>();

        Parallel.ForEach(files, file =>
        {
            var result    = _ocr.Read(file);
            var extracted = BuildInvoiceData(result);
            lock (results) { results.Add(extracted); }
        });

        return results;
    }

    private InvoiceData BuildInvoiceData(OcrResult result)
    {
        return new InvoiceData
        {
            InvoiceNumber = ExtractPattern(result.Text, @"Invoice\s*#?\s*(\w+\d+)"),
            Total         = ExtractTotal(result.Text)
        };
    }
}

using IronOcr;

public class IronOcrBatchProcessor
{
    private readonly IronTesseract _ocr = new IronTesseract();

    // Nie rate limits, no per-document cost, no network latency
    public List<InvoiceData> ProcessBatch(IEnumerable<string> files)
    {
        var results = new List<InvoiceData>();

        Parallel.ForEach(files, file =>
        {
            var result    = _ocr.Read(file);
            var extracted = BuildInvoiceData(result);
            lock (results) { results.Add(extracted); }
        });

        return results;
    }

    private InvoiceData BuildInvoiceData(OcrResult result)
    {
        return new InvoiceData
        {
            InvoiceNumber = ExtractPattern(result.Text, @"Invoice\s*#?\s*(\w+\d+)"),
            Total         = ExtractTotal(result.Text)
        };
    }
}

Imports IronOcr
Imports System.Collections.Generic
Imports System.Threading.Tasks

Public Class IronOcrBatchProcessor
    Private ReadOnly _ocr As New IronTesseract()

    ' Nie rate limits, no per-document cost, no network latency
    Public Function ProcessBatch(files As IEnumerable(Of String)) As List(Of InvoiceData)
        Dim results As New List(Of InvoiceData)()

        Parallel.ForEach(files, Sub(file)
                                    Dim result = _ocr.Read(file)
                                    Dim extracted = BuildInvoiceData(result)
                                    SyncLock results
                                        results.Add(extracted)
                                    End SyncLock
                                End Sub)

        Return results
    End Function

    Private Function BuildInvoiceData(result As OcrResult) As InvoiceData
        Return New InvoiceData With {
            .InvoiceNumber = ExtractPattern(result.Text, "Invoice\s*#?\s*(\w+\d+)"),
            .Total = ExtractTotal(result.Text)
        }
    End Function
End Class

Koszty trzyletnie dla operacji o wysokiej objętości:IronOCR Professional przy $2,999 jednorazowo versus bieżące opłaty za stronę Mindee. Punkt przełomowy zazwyczaj przypada w pierwszych miesiącach użytkowania. Strona licencyjna IronOCR zawiera wszystkie szczegóły dotyczące poziomów.

Podejście Mindee

Wzorzec asynchronicznyMindeejest oparty na operacjach wejścia/wyjścia sieciowego. Każde wywołanie jest asynchroniczne, ponieważ każde wywołanie wysyła żądanie HTTP do punktu końcowego API Mindee. Nie ma ścieżki synchronicznej. W aplikacji przetwarzającej dokumenty na żądanie użytkownika przepływ pracyMindeewymaga infrastruktury asynchronicznej w całym stosie wywołań:

// EveryMindeeoperation is async — network I/O has no synchronous equivalent
public async Task<InvoiceData> ProcessInvoiceAsync(string file)
{
    try
    {
        var inputSource = new LocalInputSource(file);
        var response    = await _client.ParseAsync<InvoiceV4>(inputSource);
        return MapResult(response.Document.Inference.Prediction);
    }
    catch (MindeeException ex)
    {
        // API errors, rate limits, authentication failures
        Console.WriteLine($"Mindee API error: {ex.Message}");
        throw;
    }
    catch (HttpRequestException ex)
    {
        // Network failure — processing halts entirely
        // Nie offline fallback path exists
        throw new Exception("Mindee requires internet connectivity", ex);
    }
}

// EveryMindeeoperation is async — network I/O has no synchronous equivalent
public async Task<InvoiceData> ProcessInvoiceAsync(string file)
{
    try
    {
        var inputSource = new LocalInputSource(file);
        var response    = await _client.ParseAsync<InvoiceV4>(inputSource);
        return MapResult(response.Document.Inference.Prediction);
    }
    catch (MindeeException ex)
    {
        // API errors, rate limits, authentication failures
        Console.WriteLine($"Mindee API error: {ex.Message}");
        throw;
    }
    catch (HttpRequestException ex)
    {
        // Network failure — processing halts entirely
        // Nie offline fallback path exists
        throw new Exception("Mindee requires internet connectivity", ex);
    }
}

Imports System
Imports System.Threading.Tasks

Public Async Function ProcessInvoiceAsync(file As String) As Task(Of InvoiceData)
    Try
        Dim inputSource = New LocalInputSource(file)
        Dim response = Await _client.ParseAsync(Of InvoiceV4)(inputSource)
        Return MapResult(response.Document.Inference.Prediction)
    Catch ex As MindeeException
        ' API errors, rate limits, authentication failures
        Console.WriteLine($"Mindee API error: {ex.Message}")
        Throw
    Catch ex As HttpRequestException
        ' Network failure — processing halts entirely
        ' No offline fallback path exists
        Throw New Exception("Mindee requires internet connectivity", ex)
    End Try
End Function

Jeśli sieć jest niedostępna — z powodu awarii połączenia, zakłóceń w działaniu usługiMindeelub ograniczenia szybkości — przetwarzanie zostaje wstrzymane. Nie ma trybu awaryjnego ani lokalnego rozwiązania zastępczego. Wdrożenia w terenie, środowiska odizolowane oraz scenariusze wymagające gwarantowanej ciągłości przetwarzania są niezgodne z architekturą Mindee.

Podejście IronOCR

IronOCR działa domyślnie w trybie synchronicznym, ponieważ przetwarzanie lokalne nie wymaga operacji wejścia/wyjścia sieciowego. Dla aplikacji, które wymagają asynchronicznych interfejsów dla zgodności z innymi operacjami zależnymi od I/O, Task.Run opakowuje synchroniczne wywołanie. Przetwarzanie leżące u podstaw jest związane z obciążeniem procesora, a nie sieci:

using IronOcr;

public class IronOcrInvoiceService
{
    private readonly IronTesseract _ocr = new IronTesseract();

    // Synchronous — local CPU-bound processing, no network dependency
    public InvoiceData ProcessInvoice(string file)
    {
        // Works with no internet, through any outage, in any environment
        var result = _ocr.Read(file);
        return BuildInvoiceData(result);
    }

    // Async wrapper for applications that require async consistency
    public async Task<InvoiceData> ProcessInvoiceAsync(string file)
    {
        return await Task.Run(() => ProcessInvoice(file));
    }
}

using IronOcr;

public class IronOcrInvoiceService
{
    private readonly IronTesseract _ocr = new IronTesseract();

    // Synchronous — local CPU-bound processing, no network dependency
    public InvoiceData ProcessInvoice(string file)
    {
        // Works with no internet, through any outage, in any environment
        var result = _ocr.Read(file);
        return BuildInvoiceData(result);
    }

    // Async wrapper for applications that require async consistency
    public async Task<InvoiceData> ProcessInvoiceAsync(string file)
    {
        return await Task.Run(() => ProcessInvoice(file));
    }
}

Imports IronOcr

Public Class IronOcrInvoiceService
    Private ReadOnly _ocr As New IronTesseract()

    ' Synchronous — local CPU-bound processing, no network dependency
    Public Function ProcessInvoice(file As String) As InvoiceData
        ' Works with no internet, through any outage, in any environment
        Dim result = _ocr.Read(file)
        Return BuildInvoiceData(result)
    End Function

    ' Async wrapper for applications that require async consistency
    Public Async Function ProcessInvoiceAsync(file As String) As Task(Of InvoiceData)
        Return Await Task.Run(Function() ProcessInvoice(file))
    End Function
End Class

IronOCR działa identycznie w kontenerach Docker bez dostępu do sieci zewnętrznej, w Azure Functions z ograniczeniami ruchu wychodzącego, w zabezpieczonych obiektach rządowych oraz w środowiskach fabrycznych bez połączenia z Internetem. Przewodnik wdrażania Docker oraz przewodnik wdrażania AWS obejmują konfigurację specyficzną dla danego środowiska. Dla zespołów, które naprawdę chcą korzystać z przetwarzania asynchronicznego z raportowaniem postępów, przewodnikIronOCR dotyczący asynchronicznego OCR omawia natywny interfejs API asynchroniczny.

Wymagania dotyczące zgodności pojawiają się po wdrożeniu

Zespoły często zaczynają od Mindee, aby szybko sprawdzić koncepcję na dokumentach, które nie zawierają danych wrażliwych, a następnie odkrywają, że wymagania produkcyjne nakładają ograniczenia dotyczące suwerenności danych. Projekt automatyzacji rozliczeń z dostawcami, który rozpoczyna się od wewnętrznych faktur testowych, napotyka na zupełnie inną sytuację, gdy pojawiają się prawdziwe faktury od dostawców zawierające numery kont bankowych, numery EIN oraz dane dotyczące cen, które zgodnie z umowami z dostawcami są klasyfikowane jako poufne. W tym momencie wybór polega na wynegocjowaniu umowy o przetwarzaniu danych (DPA) zMindeei zaakceptowaniu stałego ryzyka związanego z transmisją danych w chmurze lub przejściu na przetwarzanie lokalne. Migracja jest udokumentowana i osiągalna, ale wymaga przepisania logiki ekstrakcji, aby zastąpić ustrukturyzowane wyjścieMindeeniestandardowymi wzorcami w result.Text i result.Lines.

Wzrost wolumenu sprawia, że ceny za stronę są nie do utrzymania

Firma przetwarzająca 500 faktur miesięcznie mieści się wygodnie w planie wejściowym Mindee. Przy większych ilościach koszty za stronę znacznie rosną, a duże operacje mogą wymagać negocjacji cen z poziomu Enterprise. Zespoły, które poprawnie prognozują wzrost objętości, często przeliczają punkt rentowności przed skalowaniem: dla zespołu 5 deweloperów,IronOCR Professional przy $2,999 jednorazowo zazwyczaj odzyskuje swoje koszty względem bieżących opłatMindeew ciągu pierwszych kilku miesięcy, z zerowym bieżącym kosztem potem niezależnie od objętości.

Nowe typy dokumentów wykraczają poza gotowy katalog Mindee

Praktyczne ograniczenia modeluMindeeujawniają się, gdy proces biznesowy wymaga typów dokumentów innych niż faktury, pokwitowania i paszporty. Umowy, zamówienia z niestandardowymi układami, formularze skierowań medycznych, umowy najmu i formularze branżowe nie mają gotowego API Mindee. Szkolenie modelu niestandardowego wymaga cennika Enterprise, zebrania przykładowych dokumentów, pracy nad etykietowaniem oraz czasu na szkolenie. Zespoły zarządzające wieloma typami dokumentów w aplikacjach biznesowych uważają, że marginalny koszt dodania każdego nowego typu modeluMindeesprawia, że ekonomika ogólnej biblioteki lokalnej jest bardzo atrakcyjna.

Środowiska odizolowane lub o ograniczonym dostępie do sieci

Wykonawcy rządowi, podwykonawcy z sektóra obronnego, instytucje finansowe działające pod ścisłą kontrolą ruchu wychodzącego z sieci oraz systemy automatyki przemysłowej wdrożone w obiektach bez niezawodnego dostępu do Internetu nie mogą korzystać zMindeezgodnie z przeznaczeniem. Wymóg ten nie jest niczym niezwykłym: wiele sieci opieki zdrowotnej celowo ogranicza dostęp do Internetu dla systemów przetwarzających dokumenty pacjentów.IronOCR działa identycznie w środowiskach o ograniczonym dostępie, ponieważ nie ma żadnych zależności zewnętrznych w czasie wykonywania.

Przetwarzanie faktur dla dokumentów przesłanych przez klientów

Gdy aplikacja przyjmuje dokumenty od klientów, a nie przetwarza własne faktury wewnętrzne, kwestia prywatności ulega znacznej zmianie. Przesłanie faktury klienta doMindeeoznacza, żeMindeeotrzymuje dane dotyczące dostawców klienta, warunków płatności i relacji biznesowych. Twój klient przesłał ten dokument do Twojej aplikacji, a nie do zewnętrznej usługi AI. W przypadku platform SaaS, aplikacji fintechowych i systemów zarządzania dokumentami przetwarzających dane klientów to rozróżnienie decyduje o tym, czy przetwarzanie dokumentów w chmurze jest właściwe, niezależnie od certyfikatów zgodności Mindee.

Tworzenie wzorców ekstrakcji na podstawie surowych wyników OCR

Główną zmianą paradygmatu przy przejściu zMindeena IronOCR jest to, że ustrukturyzowany wynik musi być tworzony, a nie odbierany.Mindeezwraca prediction.InvoiceNumber?.Value jako pole wstępnie przetworzone.IronOCR zwraca result.Text jako łańcuch, a Twój kod stosuje wyrażenia regularne do ekstrakcji pól.

using IronOcr;
using System.Text.RegularExpressions;

var ocr    = new IronTesseract();
var result = ocr.Read("invoice.jpg");

// Build the extraction logicMindeepreviously handled server-side
var invoiceNumber = Regex.Match(result.Text,
    @"Invoice\s*#?\s*:?\s*([A-Z0-9]+-?\d+)",
    RegexOptions.IgnoreCase).Groups[1].Value;

var totalAmount = Regex.Match(result.Text,
    @"Total\s*(?:Due)?\s*:?\s*\$?([\d,]+\.?\d*)",
    RegexOptions.IgnoreCase).Groups[1].Value;

using IronOcr;
using System.Text.RegularExpressions;

var ocr    = new IronTesseract();
var result = ocr.Read("invoice.jpg");

// Build the extraction logicMindeepreviously handled server-side
var invoiceNumber = Regex.Match(result.Text,
    @"Invoice\s*#?\s*:?\s*([A-Z0-9]+-?\d+)",
    RegexOptions.IgnoreCase).Groups[1].Value;

var totalAmount = Regex.Match(result.Text,
    @"Total\s*(?:Due)?\s*:?\s*\$?([\d,]+\.?\d*)",
    RegexOptions.IgnoreCase).Groups[1].Value;

Imports IronOcr
Imports System.Text.RegularExpressions

Dim ocr As New IronTesseract()
Dim result = ocr.Read("invoice.jpg")

' Build the extraction logic previously handled server-side
Dim invoiceNumber = Regex.Match(result.Text, 
    "Invoice\s*#?\s*:?\s*([A-Z0-9]+-?\d+)", 
    RegexOptions.IgnoreCase).Groups(1).Value

Dim totalAmount = Regex.Match(result.Text, 
    "Total\s*(?:Due)?\s*:?\s*\$?([\d,]+\.?\d*)", 
    RegexOptions.IgnoreCase).Groups(1).Value

Biblioteki wzorów dla popularnych formatów faktur nie są skomplikowane — większość sum na fakturach opiera się na czterech lub pięciu przewidywalnych wzorach etykiet. Przed wdrożeniem wystarczy przetestować system na reprezentatywnej próbie 20–30 prawdziwych faktur od dostawców, aby wychwycić skrajne przypadki. Przewodnik po korekcji jakości obrazu obejmuje opcje przetwarzania wstępnego, które poprawiają dokładność rozpoznawania w przypadku skanów o niższej jakości.

Pewność w radzeniu sobie ze zmianami

Mindee dostarcza wartości zaufania dla poszczególnych pól: prediction.TotalAmount?.Confidence.IronOCR zapewnia całkowitą pewność dokumentu poprzez result.Confidence, co reprezentuje zbiorczą pewność silnika w uznanym tekscie. W przypadku przetwarzania faktur ogólny poziom pewności poniżej 80% zazwyczaj wskazuje na problem z jakością skanowania, który można rozwiązać poprzez przetwarzanie wstępne:

var ocr    = new IronTesseract();
var result = ocr.Read("invoice.jpg");

if (result.Confidence < 80)
{
    // Low confidence — apply preprocessing and retry
    using var input = new OcrInput();
    input.LoadImage("invoice.jpg");
    input.Deskew();
    input.DeNoise();
    input.EnhanceResolution(300);
    result = ocr.Read(input);
}

Console.WriteLine($"Confidence: {result.Confidence}%");

var ocr    = new IronTesseract();
var result = ocr.Read("invoice.jpg");

if (result.Confidence < 80)
{
    // Low confidence — apply preprocessing and retry
    using var input = new OcrInput();
    input.LoadImage("invoice.jpg");
    input.Deskew();
    input.DeNoise();
    input.EnhanceResolution(300);
    result = ocr.Read(input);
}

Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

Dim ocr As New IronTesseract()
Dim result = ocr.Read("invoice.jpg")

If result.Confidence < 80 Then
    ' Low confidence — apply preprocessing and retry
    Using input As New OcrInput()
        input.LoadImage("invoice.jpg")
        input.Deskew()
        input.DeNoise()
        input.EnhanceResolution(300)
        result = ocr.Read(input)
    End Using
End If

Console.WriteLine($"Confidence: {result.Confidence}%")

Dokumentacja dotycząca wskaźnika pewności wyjaśnia interpretację pewności i progi.

Dostosowanie wzorca asynchronicznego do synchronicznego

Cała powierzchnia APIMindeejest asynchroniczna, ponieważ jest to operacja wejścia/wyjścia sieciowego. Podstawowe metody IronOCRsą synchroniczne. Jeśli istniejąca baza kodu wykorzystujeMindeepoprzez metody asynchroniczne i wymaga zachowania interfejsu asynchronicznego dla zachowania spójności architektury, należy owinąć synchroniczne wywołanie IronOCR:

// Existing async interface preserved
public async Task<InvoiceData> ParseInvoiceAsync(string filePath)
{
    // Task.Run offloads CPU-bound work from the calling thread
    return await Task.Run(() =>
    {
        var ocr    = new IronTesseract();
        var result = ocr.Read(filePath);
        return BuildInvoiceData(result);
    });
}

// Existing async interface preserved
public async Task<InvoiceData> ParseInvoiceAsync(string filePath)
{
    // Task.Run offloads CPU-bound work from the calling thread
    return await Task.Run(() =>
    {
        var ocr    = new IronTesseract();
        var result = ocr.Read(filePath);
        return BuildInvoiceData(result);
    });
}

Imports System.Threading.Tasks

' Existing async interface preserved
Public Async Function ParseInvoiceAsync(filePath As String) As Task(Of InvoiceData)
    ' Task.Run offloads CPU-bound work from the calling thread
    Return Await Task.Run(Function()
                              Dim ocr As New IronTesseract()
                              Dim result = ocr.Read(filePath)
                              Return BuildInvoiceData(result)
                          End Function)
End Function

W przypadku scenariuszy ASP.NET o dużej przepustowości przewodnik dotyczący asynchronicznej pracy IronOCR omawia kwestie związane z pulą wątków, a przewodnik dotyczący optymalizacji prędkości porusza temat dostosowywania przepustowości dla obciążeń wsadowych.

Eliminacja zależności od infrastruktury chmurowej

Rezygnacja zMindeeeliminuje z planu operacyjnego wymagania dotyczące ruchu wychodzącego w sieci, procedury rotacji kluczy API oraz dostępność usług Mindee. Klucz APIMindeezapisany w konfiguracji został usunięty. Reguły ruchu wychodzącego z sieci zezwalające na wychodzący ruch HTTPS do punktów końcowychMindeemogą zostać cofnięte. Logika ponawiania opakowująca HttpRequestException nie jest już potrzebna. Złożoność operacyjna zmniejsza się do ustawienia klucza licencyjnego IronOCR raz przy starcie aplikacji: IronOcr.License.LicenseKey = Configuration["IronOCR:LicenseKey"].