IronOCR vs Iris OCR: Które rozwiązanie OCR powinny wybrać zespoły inżynieryjne?

Wzorzec asynchronicznego odpytywania

Wymóg asynchroniczności interfejsu API Read ma konsekwencje dla struktury kodu. Analiza obrazów przy użyciu AnalyzeAsync zwraca wynik natychmiast, ale wymaga await; Przetwarzanie PDF przez Form Recognizer wymaga WaitUntil.Completed do zablokowania do momentu zakończenia operacji, lub własne odpytywanie z UpdateStatusAsync dla prawdziwego zachowania asynchronicznego. Hierarchia wyników wymaga następnie przechodzenia przez bloki, wiersze i słowa za pomocą zagnieżdżonych pętli:

// Azure Computer Vision: image OCR
// Requires: Azure subscription + Cognitive Services resource + endpoint + API key
using Azure;
using Azure.AI.Vision.ImageAnalysis;

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

    public AzureOcrService(string endpoint, string apiKey)
    {
        // Endpoint and key provisioned in Azure portal
        _client = new ImageAnalysisClient(
            new Uri(endpoint),
            new AzureKeyCredential(apiKey));
    }

    public async Task<string> ExtractTextAsync(string imagePath)
    {
        // Document is uploaded to Microsoft Azure
        using var stream = File.OpenRead(imagePath);
        var imageData = BinaryData.FromStream(stream);

        var result = await _client.AnalyzeAsync(
            imageData,
            VisualFeatures.Read);

        var text = new StringBuilder();
        foreach (var block in result.Value.Read.Blocks)
        {
            foreach (var line in block.Lines)
            {
                text.AppendLine(line.Text);
            }
        }

        return text.ToString();
    }
}

// Azure Computer Vision: image OCR
// Requires: Azure subscription + Cognitive Services resource + endpoint + API key
using Azure;
using Azure.AI.Vision.ImageAnalysis;

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

    public AzureOcrService(string endpoint, string apiKey)
    {
        // Endpoint and key provisioned in Azure portal
        _client = new ImageAnalysisClient(
            new Uri(endpoint),
            new AzureKeyCredential(apiKey));
    }

    public async Task<string> ExtractTextAsync(string imagePath)
    {
        // Document is uploaded to Microsoft Azure
        using var stream = File.OpenRead(imagePath);
        var imageData = BinaryData.FromStream(stream);

        var result = await _client.AnalyzeAsync(
            imageData,
            VisualFeatures.Read);

        var text = new StringBuilder();
        foreach (var block in result.Value.Read.Blocks)
        {
            foreach (var line in block.Lines)
            {
                text.AppendLine(line.Text);
            }
        }

        return text.ToString();
    }
}

Imports Azure
Imports Azure.AI.Vision.ImageAnalysis
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Public Class AzureOcrService
    Private ReadOnly _client As ImageAnalysisClient

    Public Sub New(endpoint As String, apiKey As String)
        ' Endpoint and key provisioned in Azure portal
        _client = New ImageAnalysisClient(
            New Uri(endpoint),
            New AzureKeyCredential(apiKey))
    End Sub

    Public Async Function ExtractTextAsync(imagePath As String) As Task(Of String)
        ' Document is uploaded to Microsoft Azure
        Using stream = File.OpenRead(imagePath)
            Dim imageData = BinaryData.FromStream(stream)

            Dim result = Await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read)

            Dim text = New StringBuilder()
            For Each block In result.Value.Read.Blocks
                For Each line In block.Lines
                    text.AppendLine(line.Text)
                Next
            Next

            Return text.ToString()
        End Using
    End Function
End Class

Przetwarzanie PDF podwyższa jeszcze bardziej złożoność — osobny DocumentAnalysisClient z własnym punktem końcowym, AnalyzeDocumentAsync z WaitUntil.Completed, oraz inny kształt wyniku przy użyciu result.Pages i page.Lines dostępu do .Content zamiast .Text.

Szczegółowe porównanie funkcji

Podejście Azure Computer Vision

Azure nalicza opłaty za transakcję stosując ceny warstwowe w zależności od wolumenu. Skonsultuj stronę z wyceną Azure Computer Vision dla aktualnych stawek. Każda strona PDF stanowi jedną transakcję. 10-stronicowy plik PDF to 10 rozliczanych zleceń. Dostępny jest bezpłatny poziom 5 000 transakcji miesięcznie.

// Azure bills per transaction — costs grow with every document processed
// Free tier: 5,000 transactions/month
// Volume tiers apply at higher usage levels
// (Every PDF page multiplies the bill)

// Azure bills per transaction — costs grow with every document processed
// Free tier: 5,000 transactions/month
// Volume tiers apply at higher usage levels
// (Every PDF page multiplies the bill)

' Azure bills per transaction — costs grow with every document processed
' Free tier: 5,000 transactions/month
' Volume tiers apply at higher usage levels
' (Every PDF page multiplies the bill)

Przy umiarkowanych do dużych ilościach dokumentów, licencja wieczysta IronOCR szybko się zwraca w porównaniu z trwającymi kosztami transakcji Azure, po czym każdy dodatkowy dokument to oszczędność.

Podejście IronOCR

Model cenowy IronOCR opiera się na jednej kwocie. Zainstaluj pakiet NuGet, ustaw klucz licencyjny i przetwarzaj dowolną ilość danych bez licznika:

// Install: dotnet add package IronOcr
// License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

var ocr = new IronTesseract();

// Process 1 document or 1 million — same cost
foreach (var path in documentPaths)
{
    var result = ocr.Read(path);
    Console.WriteLine($"Processed: {path}");
}

// Multi-page PDFs — no per-page billing
foreach (var path in pdfPaths)
{
    // 1 page or 100 pages, still no extra cost
    var result = ocr.Read(path);
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed");
}

// Install: dotnet add package IronOcr
// License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

var ocr = new IronTesseract();

// Process 1 document or 1 million — same cost
foreach (var path in documentPaths)
{
    var result = ocr.Read(path);
    Console.WriteLine($"Processed: {path}");
}

// Multi-page PDFs — no per-page billing
foreach (var path in pdfPaths)
{
    // 1 page or 100 pages, still no extra cost
    var result = ocr.Read(path);
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed");
}

' Install: dotnet add package IronOcr
' License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

Dim ocr As New IronTesseract()

' Process 1 document or 1 million — same cost
For Each path In documentPaths
    Dim result = ocr.Read(path)
    Console.WriteLine($"Processed: {path}")
Next

' Multi-page PDFs — no per-page billing
For Each path In pdfPaths
    ' 1 page or 100 pages, still no extra cost
    Dim result = ocr.Read(path)
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed")
Next

Nie są potrzebne żadne pomiary, śledzenie użytkowania ani alerty budżetowe. Przewidywalne koszty od pierwszego dnia. Aby zapoznać się z kompletnym przewodnikiem dla początkujących, zapoznaj się z samouczkiem dotyczącym odczytywania tekstu z obrazów.

Podejście Azure Computer Vision

Nawet przy regionalnym wyborze punktu końcowego i podpisanej umowie o współpracy biznesowej przepływ danych jest stały:

// Azure: data flow for every OCR call
// 1. Your application reads the file
// 2. File is serialized to BinaryData
// 3. HTTPS transmission to Azure data center
// 4. Microsoft infrastructure processes the document
// 5. Result returned over HTTPS
// 6. You parse the result

using var stream = File.OpenRead(imagePath);
var imageData = BinaryData.FromStream(stream);  // Document in memory

// This call transmits your document to Azure
var result = await _client.AnalyzeAsync(
    imageData,           // Document leaves your network here
    VisualFeatures.Read);

// Azure: data flow for every OCR call
// 1. Your application reads the file
// 2. File is serialized to BinaryData
// 3. HTTPS transmission to Azure data center
// 4. Microsoft infrastructure processes the document
// 5. Result returned over HTTPS
// 6. You parse the result

using var stream = File.OpenRead(imagePath);
var imageData = BinaryData.FromStream(stream);  // Document in memory

// This call transmits your document to Azure
var result = await _client.AnalyzeAsync(
    imageData,           // Document leaves your network here
    VisualFeatures.Read);

Imports System.IO
Imports Azure.AI.FormRecognizer.DocumentAnalysis

' Azure: data flow for every OCR call
' 1. Your application reads the file
' 2. File is serialized to BinaryData
' 3. HTTPS transmission to Azure data center
' 4. Microsoft infrastructure processes the document
' 5. Result returned over HTTPS
' 6. You parse the result

Using stream As FileStream = File.OpenRead(imagePath)
    Dim imageData As BinaryData = BinaryData.FromStream(stream) ' Document in memory

    ' This call transmits your document to Azure
    Dim result = Await _client.AnalyzeAsync(
        imageData,           ' Document leaves your network here
        VisualFeatures.Read)
End Using

Sieć typu air-gapped nie ma żadnego dostępu do adresu URL punktu końcowego — usługaAzure Computer Visionnie posiada trybu offline. Dla organizacji prowadzących SCIF, obiekty wojskowe lub izolowane środowiska przetwarzania usługa jest niekompatybilna pod względem architektury, niezależnie od ceny.

Podejście IronOCR

IronOCR przetwarza dokumenty w ramach procesu wywołującego. Nie ma połączenia wychodzącego:

// IronOCR: data never leaves your infrastructure
using IronOcr;

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

    public string ExtractText(string imagePath)
    {
        // Runs entirely in-process
        // Nie network call, no serialization to external endpoint
        var result = _ocr.Read(imagePath);
        return result.Text;
    }

    public string ExtractFromPdf(string pdfPath)
    {
        // PDF processed entirely on-premise, native support
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    }

    public string ExtractFromEncryptedPdf(string pdfPath, string password)
    {
        // Encrypted PDFs also stay local
        using var input = new OcrInput();
        input.LoadPdf(pdfPath, Password: password);
        return _ocr.Read(input).Text;
    }
}

// IronOCR: data never leaves your infrastructure
using IronOcr;

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

    public string ExtractText(string imagePath)
    {
        // Runs entirely in-process
        // Nie network call, no serialization to external endpoint
        var result = _ocr.Read(imagePath);
        return result.Text;
    }

    public string ExtractFromPdf(string pdfPath)
    {
        // PDF processed entirely on-premise, native support
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    }

    public string ExtractFromEncryptedPdf(string pdfPath, string password)
    {
        // Encrypted PDFs also stay local
        using var input = new OcrInput();
        input.LoadPdf(pdfPath, Password: password);
        return _ocr.Read(input).Text;
    }
}

Imports IronOcr

Public Class OnPremiseOcrService
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractText(imagePath As String) As String
        ' Runs entirely in-process
        ' No network call, no serialization to external endpoint
        Dim result = _ocr.Read(imagePath)
        Return result.Text
    End Function

    Public Function ExtractFromPdf(pdfPath As String) As String
        ' PDF processed entirely on-premise, native support
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)
            Return _ocr.Read(input).Text
        End Using
    End Function

    Public Function ExtractFromEncryptedPdf(pdfPath As String, password As String) As String
        ' Encrypted PDFs also stay local
        Using input As New OcrInput()
            input.LoadPdf(pdfPath, Password:=password)
            Return _ocr.Read(input).Text
        End Using
    End Function
End Class

Wdrożenie Docker całkowicie eliminuje wymagania dotyczące sieci wychodzącej:

FROM mcr.microsoft.com/dotnet/aspnet:8.0
RUN apt-get update && apt-get install -y libgdiplus
WORKDIR /app
COPY --from=build /app/publish .
ENV IRONOCR_LICENSE=your-key
# Nie Azure endpoint, no API key, no outbound network rules needed
ENTRYPOINT ["dotnet", "YourApp.dll"]

W przypadku podmiotów objętych HIPAA, zgodności z ITAR lub scenariuszy FedRAMP z izolacją fizyczną,IronOCR eliminuje całe ryzyko związane z zewnętrznymi podmiotami przetwarzającymi dane. Zapoznaj się z przewodnikiem wdrażania w Azure, aby uruchomićIronOCR w infrastrukturze Azure, zachowując dokumenty lokalnie na instancji obliczeniowej, oraz z przewodnikiem wdrażania Docker, aby skonfigurować kontener.

Podejście Azure Computer Vision

Każde wywołanie OCR w Azure wymaga await. Kod produkcyjny dodaje logikę ponownej próby dla błędów 429 związanych z limitem szybkości oraz błędów usługi 5xx. Minimalna implementacja produkcyjna wygląda następująco:

public async Task<string> RobustExtractAsync(string imagePath)
{
    const int maxRetries = 3;
    int attempt = 0;

    while (attempt < maxRetries)
    {
        try
        {
            using var stream = File.OpenRead(imagePath);
            var imageData = BinaryData.FromStream(stream);

            var result = await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read);

            return string.Join("\n",
                result.Value.Read.Blocks
                    .SelectMany(b => b.Lines)
                    .Select(l => l.Text));
        }
        catch (RequestFailedException ex) when (ex.Status == 429)
        {
            // Rate limited — Azure caps S1 at 10 TPS
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
        catch (RequestFailedException ex) when (ex.Status >= 500)
        {
            // Azure service error
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(1));
        }
        catch (RequestFailedException ex)
        {
            // Client error — bad credential, invalid endpoint
            throw new Exception($"Azure OCR failed: {ex.Message}", ex);
        }
    }

    throw new Exception("Max retries exceeded for Azure OCR");
}

public async Task<string> RobustExtractAsync(string imagePath)
{
    const int maxRetries = 3;
    int attempt = 0;

    while (attempt < maxRetries)
    {
        try
        {
            using var stream = File.OpenRead(imagePath);
            var imageData = BinaryData.FromStream(stream);

            var result = await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read);

            return string.Join("\n",
                result.Value.Read.Blocks
                    .SelectMany(b => b.Lines)
                    .Select(l => l.Text));
        }
        catch (RequestFailedException ex) when (ex.Status == 429)
        {
            // Rate limited — Azure caps S1 at 10 TPS
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
        catch (RequestFailedException ex) when (ex.Status >= 500)
        {
            // Azure service error
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(1));
        }
        catch (RequestFailedException ex)
        {
            // Client error — bad credential, invalid endpoint
            throw new Exception($"Azure OCR failed: {ex.Message}", ex);
        }
    }

    throw new Exception("Max retries exceeded for Azure OCR");
}

Imports System.IO
Imports System.Threading.Tasks

Public Async Function RobustExtractAsync(imagePath As String) As Task(Of String)
    Const maxRetries As Integer = 3
    Dim attempt As Integer = 0

    While attempt < maxRetries
        Try
            Using stream = File.OpenRead(imagePath)
                Dim imageData = BinaryData.FromStream(stream)

                Dim result = Await _client.AnalyzeAsync(
                    imageData,
                    VisualFeatures.Read)

                Return String.Join(vbCrLf,
                    result.Value.Read.Blocks _
                        .SelectMany(Function(b) b.Lines) _
                        .Select(Function(l) l.Text))
            End Using
        Catch ex As RequestFailedException When ex.Status = 429
            ' Rate limited — Azure caps S1 at 10 TPS
            attempt += 1
            Await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)))
        Catch ex As RequestFailedException When ex.Status >= 500
            ' Azure service error
            attempt += 1
            Await Task.Delay(TimeSpan.FromSeconds(1))
        Catch ex As RequestFailedException
            ' Client error — bad credential, invalid endpoint
            Throw New Exception($"Azure OCR failed: {ex.Message}", ex)
        End Try
    End While

    Throw New Exception("Max retries exceeded for Azure OCR")
End Function

Nie jest to defensywna nadmierna inżynieria — jest to minimum wymagane dla każdego wywołania interfejsu API platformy Azure w środowisku produkcyjnym. Limity szybkości, przerwy w działaniu usług i przejściowe błędy to rzeczywiste sytuacje, z którymi spotka się każdy użytkownik platformy Azure.

Podejście IronOCR

Lokalne przetwarzanie eliminuje powierzchnię awarii sieci. Zakres obsługi błędów ogranicza się do systemu plików i walidacji danych wejściowych:

// Nie async required — local processing returns synchronously
public string ExtractText(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return result.Text;
}

// One line for simple cases
public string OneLineOcr(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// Confidence-aware extraction
public (string Text, double Confidence) ExtractWithConfidence(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return (result.Text, result.Confidence);
}

// Nie async required — local processing returns synchronously
public string ExtractText(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return result.Text;
}

// One line for simple cases
public string OneLineOcr(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// Confidence-aware extraction
public (string Text, double Confidence) ExtractWithConfidence(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return (result.Text, result.Confidence);
}

Imports IronTesseract

Public Class OcrProcessor
    ' Nie async required — local processing returns synchronously
    Public Function ExtractText(imagePath As String) As String
        Dim result = New IronTesseract().Read(imagePath)
        Return result.Text
    End Function

    ' One line for simple cases
    Public Function OneLineOcr(imagePath As String) As String
        Return New IronTesseract().Read(imagePath).Text
    End Function

    ' Confidence-aware extraction
    Public Function ExtractWithConfidence(imagePath As String) As (Text As String, Confidence As Double)
        Dim result = New IronTesseract().Read(imagePath)
        Return (result.Text, result.Confidence)
    End Function
End Class

Bez RequestFailedException, bez pętli ponownych prób, bez koordynacji Task.WhenAll dla zadań wsadowych. Jeśli potrzebujesz asynchroniczności do integracji z asynchronicznym potokiem kontrolera, Task.Run(() => ocr.Read(path)) opakowuje synchroniczne wywołanie bez zmian strukturalnych samej logiki OCR. Dokumentacja API IronTesseract obejmuje pełny interfejs synchroniczny. W przypadku zadań, które rzeczywiście wymagają wzorców asynchronicznych,IronOCR udostępnia również dedykowany przewodnik po asynchronicznym OCR.

Podejście Azure Computer Vision

Sekwencja konfiguracji platformy Azure przed napisaniem jakiegokolwiek kodu OCR:

1. Utwórz konto Azure, jeśli jeszcze go nie masz.
2. Przejdź do portalu Azure i utwórz zasób Cognitive Services (lub zasób Azure AI Services).
3. Wybierz poziom cenowy i region.
4. Skopiuj URL punktu końcowego (format: https://your-resource.cognitiveservices.azure.com/).
5. Skopiuj jeden z dwóch kluczy API.
6. Przechowuj obie wartości bezpiecznie — w zmiennych środowiskowych, Azure Key Vault lub appsettings.json (tylko poza produkcją).
7. Zainstaluj Azure.AI.Vision.ImageAnalysis przez NuGet.
8. Zainicjalizuj ImageAnalysisClient z punktem końcowym i poświadczeniami.

Dla przetwarzania PDF powtórz kroki od 2 do 8 dla zasobu Form Recognizer przy użyciu innego pakietu NuGet (Azure.AI.FormRecognizer) i innej klasy klienta (DocumentAnalysisClient).

appsettings.json przechowuje punkt końcowy i klucz:

{
  "Azure": {
    "ComputerVision": {
      "Endpoint": "https://your-resource.cognitiveservices.azure.com/",
      "ApiKey": "your-api-key"
    }
  }
}

Rotacja kluczy API, obsługa wygasania poświadczeń oraz zarządzanie adresami URL punktów końcowych w różnych środowiskach (rozwojowym, testowym, produkcyjnym) to bieżące zadania operacyjne, które nie mają odpowiednika w przetwarzaniu lokalnym.

Podejście IronOCR

Przewodnik konfiguracji IronTesseract sprowadza konfigurację do dwóch kroków:

dotnet add package IronOcr

// Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// Then use immediately — no endpoint, no credential rotation, no portal setup
var text = new IronTesseract().Read("document.jpg").Text;

// Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// Then use immediately — no endpoint, no credential rotation, no portal setup
var text = new IronTesseract().Read("document.jpg").Text;

Imports System

' Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

' Then use immediately — no endpoint, no credential rotation, no portal setup
Dim text As String = (New IronTesseract()).Read("document.jpg").Text

Klucz licencyjny jest ciągiem statycznym. Nie wygasa na żądanie, nie wymaga rotacji i nie wysyła zapytania do serwera w celu weryfikacji po aktywacji. Środowiska wdrożeniowe nie wymagają reguł zapory wychodzącej, aby funkcja OCR działała.

Wymagania dotyczące zgodności Przetwarzanie w chmurze

Niezależny dostawca oprogramowania z branży medycznej, tworzący system zarządzania dokumentami, zaczyna od Azure Computer Vision, ponieważ można go szybko zintegrować. Wtedy pojawia się pierwszy klient korporacyjny — sieć szpitali z inspektorem bezpieczeństwa HIPAA, który zadaje dwa pytania: "Gdzie trafiają nasze dane medyczne (PHI)?" oraz "Czy możecie pokazać nam umowę o współpracy biznesowej (BAA) dotyczącą tej strony trzeciej?". Azure ma umowę BAA, ale odpowiedź na pierwsze pytanie — "centra danych Microsoftu" — wywołuje długotrwały przegląd bezpieczeństwa, prośbę o raporty audytowe Microsoftu oraz harmonogram zapewnienia zgodności, który opóźnia podpisanie umowy. Przejście na IronOCR całkowicie eliminuje ten problem. Dane PHI nigdy nie opuszczają środowiska klienta. Zakres zgodności ogranicza się do organizacji klienta.

Wzrost wolumenu sprawia, że ceny za transakcję stają się nieopłacalne

Zespół operacyjny uruchamia proces przetwarzania faktur na poziomie 5000 dokumentów miesięcznie — co spokojnie mieści się w ramach bezpłatnego pakietu Azure. W miarę wzrostu wolumenu, koszty za transakcję rosną z każdym przetworzonym dokumentem.IronOCR Professional ($2,999) to jednorazowy zakup bez opłat za dokument. Zespoły, które przewidują nawet umiarkowany wzrost wolumenu, szybko osiągają próg rentowności, a każdy dodatkowy dokument to oszczędność.

Opóźnienia sieciowe wpływają na umowy SLA dotyczące przetwarzania

Usługa przetwarzania dokumentów ma na celu zapewnienie kompleksowej umowy SLA w ciągu 2 sekund.Azure Computer Visionpowoduje opóźnienie sieciowe wynoszące 200–800 ms w przypadku wywołań w tym samym regionie oraz 500–2000 ms w przypadku wdrożeń międzyregionowych — przed samym obliczeniem OCR. Pod obciążeniem limit 10 TPS na S1 wymusza tworzenie kolejki, co dodatkowo zwiększa opóźnienia.IronOCR przetwarza pojedynczy obraz o rozdzielczości 300 DPI w czasie 100–400 ms na standardowym sprzęcie serwerowym bez kolejki, limitu szybkości i przeskoków sieciowych. Umowa SLA staje się przewidywalna, ponieważ zależy wyłącznie od sprzętu, a nie od stanu usług Azure czy warunków sieciowych.

Wymagania dotyczące infrastruktury typu air-gapped

Wykonawcy z sektóra obronnego, agencje wywiadowcze i operatorzy infrastruktury krytycznej obsługują obciążenia w sieciach, które z założenia nie mają połączenia z Internetem.Azure Computer Visionjest technicznie niekompatybilny z tymi środowiskami — nie można uzyskać dostępu do punktu końcowego. Zespoły w tych sektórach potrzebują biblioteki, która wdraża się jako samodzielny plik binarny, działa bez połączeń wychodzących i przechodzi kontrole bezpieczeństwa, które wyraźnie zabraniają transmisji danych do chmury. WdrożenieIronOCRw systemie Linux oraz obsługa Docker sprawiają, że można go wdrożyć w środowiskach o ograniczonym dostępie bez konieczności modyfikacji.

Uproszczenie wdrażania w wielu środowiskach

Zespół zarządzający środowiskami deweloperskimi, testowymi i produkcyjnymi dla aplikacji SaaS korzysta z trzech zasobów Azure Cognitive Services, trzech zestawów kluczy API oraz trzech adresów URL punktów końcowych — z których każdy wymaga bezpiecznego przechowywania, zasad rotacji oraz konfiguracji dostosowanej do danego środowiska. Każde środowisko wdrożeniowe wymaga dostępu do sieci wychodzącej do platformy Azure.IronOCR redukuje konfigurację per-środowisko do jednej zmiennej środowiskowej (IRONOCR_LICENSE), eliminuje wymóg dostępu do sieci i usuwa operacyjne obciążenie zarządzania poświadczeniami w różnych środowiskach.

Wzorzec asynchroniczny do synchronicznego

Kod użytkownika Azure jest async z konieczności.IronOCR nie wymaga asynchroniczności, ale przejście jest mechaniczne. Zamień typy zwrotów async Task<string> na string, usuń słowa kluczowe await i async oraz usuń pętlę ponownych prób. Jeśli metoda wywołująca jest kontrolerem ASP.NET lub usługą, która musi pozostać asynchroniczna, opakuj wywołanie IronOCR w Task.Run:

// Before: Azure async chain
public async Task<string> ReadTextAsync(string imagePath)
{
    using var stream = File.OpenRead(imagePath);
    var data = BinaryData.FromStream(stream);
    var result = await _client.AnalyzeAsync(data, VisualFeatures.Read);
    return string.Join("\n", result.Value.Read.Blocks
        .SelectMany(b => b.Lines)
        .Select(l => l.Text));
}

// After:IronOCR synchronous
public string ReadText(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// If async signature must be preserved for interface compatibility
public Task<string> ReadTextAsync(string imagePath)
{
    return Task.Run(() => new IronTesseract().Read(imagePath).Text);
}

// Before: Azure async chain
public async Task<string> ReadTextAsync(string imagePath)
{
    using var stream = File.OpenRead(imagePath);
    var data = BinaryData.FromStream(stream);
    var result = await _client.AnalyzeAsync(data, VisualFeatures.Read);
    return string.Join("\n", result.Value.Read.Blocks
        .SelectMany(b => b.Lines)
        .Select(l => l.Text));
}

// After:IronOCR synchronous
public string ReadText(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// If async signature must be preserved for interface compatibility
public Task<string> ReadTextAsync(string imagePath)
{
    return Task.Run(() => new IronTesseract().Read(imagePath).Text);
}

Imports System.IO
Imports System.Threading.Tasks
Imports System.Linq

' Before: Azure async chain
Public Async Function ReadTextAsync(imagePath As String) As Task(Of String)
    Using stream = File.OpenRead(imagePath)
        Dim data = BinaryData.FromStream(stream)
        Dim result = Await _client.AnalyzeAsync(data, VisualFeatures.Read)
        Return String.Join(vbLf, result.Value.Read.Blocks _
            .SelectMany(Function(b) b.Lines) _
            .Select(Function(l) l.Text))
    End Using
End Function

' After: IronOCR synchronous
Public Function ReadText(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

' If async signature must be preserved for interface compatibility
Public Function ReadTextAsync(imagePath As String) As Task(Of String)
    Return Task.Run(Function() New IronTesseract().Read(imagePath).Text)
End Function

Normalizacja skali pewności

Azure Computer Vision zwraca zaufanie co do słów jako float między 0 a 1.IronOCR zwraca zaufanie jako double w skali 0-100. Każdy kod, który przekracza wartości progowe zaufania platformy Azure, wymaga dostosowania:

// Azure: confidence is 0.0 - 1.0
foreach (var word in line.Words)
{
    if (word.Confidence > 0.85f) { /* high confidence */ }
}

// IronOCR: confidence is 0 - 100
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    if (word.Confidence > 85.0) { /* equivalent threshold */ }
}
Console.WriteLine($"Overall: {result.Confidence}%");

// Azure: confidence is 0.0 - 1.0
foreach (var word in line.Words)
{
    if (word.Confidence > 0.85f) { /* high confidence */ }
}

// IronOCR: confidence is 0 - 100
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    if (word.Confidence > 85.0) { /* equivalent threshold */ }
}
Console.WriteLine($"Overall: {result.Confidence}%");

Imports IronOcr

' Azure: confidence is 0.0 - 1.0
For Each word In line.Words
    If word.Confidence > 0.85F Then
        ' high confidence
    End If
Next

' IronOCR: confidence is 0 - 100
Dim result = New IronTesseract().Read(imagePath)
For Each word In result.Words
    If word.Confidence > 85.0 Then
        ' equivalent threshold
    End If
Next
Console.WriteLine($"Overall: {result.Confidence}%")

Dokumentacja API OcrResult zawiera opis wszystkich właściwości wyników, w tym skali pewności. Przewodnik dotyczący oceny pewności obejmuje wybór progów i interpretację poszczególnych elementów.

Konsolidacja usług przetwarzania plików PDF

Azure dzieli OCR obrazów i OCR plików PDF na dwie oddzielne usługi z osobnymi klientami, pakietami NuGet i konfiguracjami punktów końcowych. Migracja oznacza konsolidację obu ścieżek do jednej instancji IronTesseract. Metoda OcrInput.LoadPdf akceptuje ścieżkę do pliku, strumień lub tablicę bajtów, z opcjonalnym parametrem Password dla zaszyfrowanych plików — nie jest wymagany drugi klient:

// Before: Two separate Azure clients for images vs PDFs
// Image: ImageAnalysisClient + AnalyzeAsync
// PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

// After: One IronTesseract instance handles both
var ocr = new IronTesseract();

// Image
var imageResult = ocr.Read("document.jpg");

// PDF (same client, same Read method)
using var pdfInput = new OcrInput();
pdfInput.LoadPdf("document.pdf");
var pdfResult = ocr.Read(pdfInput);

// Password-protected PDF
using var encInput = new OcrInput();
encInput.LoadPdf("secured.pdf", Password: "secret");
var encResult = ocr.Read(encInput);

// Wynik w formacie PDF z możliwością wyszukiwania — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

// Before: Two separate Azure clients for images vs PDFs
// Image: ImageAnalysisClient + AnalyzeAsync
// PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

// After: One IronTesseract instance handles both
var ocr = new IronTesseract();

// Image
var imageResult = ocr.Read("document.jpg");

// PDF (same client, same Read method)
using var pdfInput = new OcrInput();
pdfInput.LoadPdf("document.pdf");
var pdfResult = ocr.Read(pdfInput);

// Password-protected PDF
using var encInput = new OcrInput();
encInput.LoadPdf("secured.pdf", Password: "secret");
var encResult = ocr.Read(encInput);

// Wynik w formacie PDF z możliwością wyszukiwania — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

' Before: Two separate Azure clients for images vs PDFs
' Image: ImageAnalysisClient + AnalyzeAsync
' PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

' After: One IronTesseract instance handles both
Dim ocr As New IronTesseract()

' Image
Dim imageResult = ocr.Read("document.jpg")

' PDF (same client, same Read method)
Using pdfInput As New OcrInput()
    pdfInput.LoadPdf("document.pdf")
    Dim pdfResult = ocr.Read(pdfInput)

    ' Password-protected PDF
    Using encInput As New OcrInput()
        encInput.LoadPdf("secured.pdf", Password:="secret")
        Dim encResult = ocr.Read(encInput)

        ' Wynik w formacie PDF z możliwością wyszukiwania — no manual construction
        pdfResult.SaveAsSearchablePdf("searchable-output.pdf")
    End Using
End Using

Przewodnik dotyczący danych wejściowych w formacie PDF obejmuje wybór zakresu stron, dane wejściowe strumieniowe oraz natywny proces renderowania plików PDF. Informacje na temat danych wejściowych w postaci obrazów można znaleźć w przewodniku dotyczącym danych wejściowych w postaci obrazów.

Pobieranie danych strukturalnych bez rozpoznawania formularzy

Zespoły używające predefiniowanych modeli Form Recognizer (faktury, pokwitowania, dokumenty tożsamości) do ekstrakcji pól muszą powtórzyć tę logikę ekstrakcji w IronOCR przy użyciu OCR opartego na regionach z CropRectangle. Ekstrakcja pozycyjna jest jawna, a nie oparta na modelu:

// Form Recognizer extracted named fields automatically
// IronOCR: define extraction zones for known document layouts
var ocr = new IronTesseract();

// Define regions matching the document template
var vendorZone   = new CropRectangle(0,   0,   300, 100);
var invoiceDate  = new CropRectangle(400, 0,   200, 50);
var totalAmount  = new CropRectangle(400, 500, 200, 100);

string vendor, date, total;

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", vendorZone);
    vendor = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", invoiceDate);
    date = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", totalAmount);
    total = ocr.Read(input).Text.Trim();
}

// Form Recognizer extracted named fields automatically
// IronOCR: define extraction zones for known document layouts
var ocr = new IronTesseract();

// Define regions matching the document template
var vendorZone   = new CropRectangle(0,   0,   300, 100);
var invoiceDate  = new CropRectangle(400, 0,   200, 50);
var totalAmount  = new CropRectangle(400, 500, 200, 100);

string vendor, date, total;

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", vendorZone);
    vendor = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", invoiceDate);
    date = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", totalAmount);
    total = ocr.Read(input).Text.Trim();
}

Imports IronOcr

' Form Recognizer extracted named fields automatically
' IronOCR: define extraction zones for known document layouts
Dim ocr As New IronTesseract()

' Define regions matching the document template
Dim vendorZone As New CropRectangle(0, 0, 300, 100)
Dim invoiceDate As New CropRectangle(400, 0, 200, 50)
Dim totalAmount As New CropRectangle(400, 500, 200, 100)

Dim vendor As String
Dim [date] As String
Dim total As String

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", vendorZone)
    vendor = ocr.Read(input).Text.Trim()
End Using

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", invoiceDate)
    [date] = ocr.Read(input).Text.Trim()
End Using

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", totalAmount)
    total = ocr.Read(input).Text.Trim()
End Using

Przewodnik OCR opartego na regionach szczegółowo opisuje użycie CropRectangle. W przypadku procesów związanych z fakturami samouczek dotyczący OCR faktur pokazuje pełny wzorzec wyodrębniania danych.