Tesseract対Microsoft OCR：直接比較

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

public class MindeeInvoiceService
{
    private readonly MindeeClient _client;

    public MindeeInvoiceService(string apiKey)
    {
        // API key authenticates with ミンディー cloud
        _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 to ミンディー — 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 to ミンディー cloud
            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 ミンディー 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 ミンディー — 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 ミンディー 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

// Every field in this response existed because ミンディー received your document
var prediction = response.Document.Inference.Prediction;

// Financial identifiers — transmitted to ミンディー cloud
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 to ミンディー cloud
var vendorTaxId   = prediction.SupplierCompanyRegistrations?.FirstOrDefault()?.Value;
var customerReg   = prediction.CustomerCompanyRegistrations?.FirstOrDefault()?.Value;

// Business intelligence — transmitted to ミンディー cloud
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 ミンディー received your document
Dim prediction = response.Document.Inference.Prediction

' Financial identifiers — transmitted to ミンディー 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 ミンディー cloud
Dim vendorTaxId = prediction.SupplierCompanyRegistrations?.FirstOrDefault()?.Value
Dim customerReg = prediction.CustomerCompanyRegistrations?.FirstOrDefault()?.Value

' Business intelligence — transmitted to ミンディー 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()

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

// These work with ミンディー pre-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

Imports System.Threading.Tasks

' These work with ミンディー pre-built APIs:
Dim invoiceResponse = Await _client.ParseAsync(Of InvoiceV4)(inputSource)
Dim receiptResponse = Await _client.ParseAsync(Of ReceiptV5)(inputSource)
Dim passportResponse = Await _client.ParseAsync(Of PassportV1)(inputSource)

' These require custom training (Enterprise plan + labeling + lead time):
' client.ParseAsync(Of ContractV1)(inputSource)      ' not available
' client.ParseAsync(Of MedicalFormV1)(inputSource)   ' not available
' client.ParseAsync(Of ShippingLabelV1)(inputSource) ' not available

using IronOcr;
using System.Text.RegularExpressions;

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

    // Invoices — same approach as ミンディー covers
    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*)")
        };
    }

    // 契約 — ミンディー has 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,]+)")
        };
    }

    // 医療フォーム — ミンディー has 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 as ミンディー covers
    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

    ' 契約 — ミンディー has 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

    ' 医療フォーム — ミンディー has 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

// ミンディー batch: 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

' ミンディー batch: 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

using IronOcr;

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

    // なし 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()

    ' なし 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

// Every ミンディー operation 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
        // なし 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
        ' なし offline fallback path exists
        Throw New Exception("Mindee requires internet connectivity", ex)
    End Try
End Function

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

using IronOcr;
using System.Text.RegularExpressions;

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

// Build the extraction logic ミンディー previously 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

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

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