Alternatywy dla funkcji OCR w programie Acrobat DC z wykorzystaniem IronOCR

Konfiguracja poświadczeń konta usługowego

Poniższy kod z google-vision-vs-ironocr-examples.cs ilustruje wzorzec inicjalizacji klienta. To, co ukrywa linia instancji, to warunek wstępny: zmienna środowiskowa GOOGLE_APPLICATION_CREDENTIALS już musi wskazywać na prawidłowy plik klucza JSON konta usługi na bieżącej maszynie:

using Google.Cloud.Vision.V1;

public class GoogleVisionService
{
    private readonly ImageAnnotatorClient _client;

    public GoogleVisionService()
    {
        // Requires GOOGLE_APPLICATION_CREDENTIALS env var
        // pointing to a service account JSON key file
        _client = ImageAnnotatorClient.Create();
    }

    public string DetectText(string imagePath)
    {
        // WARNING: Image uploaded to Google Cloud
        var image = Image.FromFile(imagePath);
        var response = _client.DetectText(image);

        if (response.Count > 0)
        {
            return response[0].Description;
        }

        return string.Empty;
    }
}

using Google.Cloud.Vision.V1;

public class GoogleVisionService
{
    private readonly ImageAnnotatorClient _client;

    public GoogleVisionService()
    {
        // Requires GOOGLE_APPLICATION_CREDENTIALS env var
        // pointing to a service account JSON key file
        _client = ImageAnnotatorClient.Create();
    }

    public string DetectText(string imagePath)
    {
        // WARNING: Image uploaded to Google Cloud
        var image = Image.FromFile(imagePath);
        var response = _client.DetectText(image);

        if (response.Count > 0)
        {
            return response[0].Description;
        }

        return string.Empty;
    }
}

Imports Google.Cloud.Vision.V1

Public Class GoogleVisionService
    Private ReadOnly _client As ImageAnnotatorClient

    Public Sub New()
        ' Requires GOOGLE_APPLICATION_CREDENTIALS env var
        ' pointing to a service account JSON key file
        _client = ImageAnnotatorClient.Create()
    End Sub

    Public Function DetectText(imagePath As String) As String
        ' WARNING: Image uploaded to Google Cloud
        Dim image = Image.FromFile(imagePath)
        Dim response = _client.DetectText(image)

        If response.Count > 0 Then
            Return response(0).Description
        End If

        Return String.Empty
    End Function
End Class

Plik klucza JSON zawiera klucz prywatny RSA, adres e-mail klienta oraz identyfikatory projektu. Nie wolno go nigdy umieszczać w systemie kontroli wersji, należy go wykluczyć z obrazów Docker, należy go okresowo wymieniać oraz chronić odpowiednimi uprawnieniami systemu plików. Narażony klucz zapewnia dostęp do API do momentu ręcznego cofnięcia go w konsoli GCP.

Szczegółowe porównanie funkcji

Podejście Google Cloud Vision

Inicjalizacja klienta wygląda jak jedna linia, ale ta linia rzuci RpcException z StatusCode.PermissionDenied, chyba że spełniono siedem warunków wstępnych. Z google-cloud-vision-migration-examples.cs, konfiguracja poświadczeń opowiada całą historię:

public GoogleVisionCredentialSetup()
{
    // BEFORE: Requires GOOGLE_APPLICATION_CREDENTIALS environment variable
    // pointing to a service account JSON key file:
    // export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"
    //
    // The JSON file contains sensitive data:
    // - private_key: RSA private key
    // - client_email: service account email
    // - project_id: GCP project identifier
    //
    // Security concerns:
    // - Key file must never be committed to source control
    // - Key file must be rotated periodically
    // - Key file must be protected with file system permissions
    // - Key file compromise grants API access until revoked

    _client = ImageAnnotatorClient.Create();
}

public GoogleVisionCredentialSetup()
{
    // BEFORE: Requires GOOGLE_APPLICATION_CREDENTIALS environment variable
    // pointing to a service account JSON key file:
    // export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"
    //
    // The JSON file contains sensitive data:
    // - private_key: RSA private key
    // - client_email: service account email
    // - project_id: GCP project identifier
    //
    // Security concerns:
    // - Key file must never be committed to source control
    // - Key file must be rotated periodically
    // - Key file must be protected with file system permissions
    // - Key file compromise grants API access until revoked

    _client = ImageAnnotatorClient.Create();
}

Public Sub New()
    ' BEFORE: Requires GOOGLE_APPLICATION_CREDENTIALS environment variable
    ' pointing to a service account JSON key file:
    ' export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"
    '
    ' The JSON file contains sensitive data:
    ' - private_key: RSA private key
    ' - client_email: service account email
    ' - project_id: GCP project identifier
    '
    ' Security concerns:
    ' - Key file must never be committed to source control
    ' - Key file must be rotated periodically
    ' - Key file must be protected with file system permissions
    ' - Key file compromise grants API access until revoked

    _client = ImageAnnotatorClient.Create()
End Sub

W przypadku wdrożenia opartego na Dockerze plik klucza JSON musi zostać zamontowany jako wolumin tajny lub wstrzyknięty za pośrednictwem sekretów Kubernetes. W konfiguracji wieloregionalnej każdy region wymaga tej samej konfiguracji poświadczeń. Rotacja kluczy to proces ręczny, który wymaga jednoczesnej aktualizacji przy każdym wdrożeniu lub zaakceptowania okresu, w którym zarówno stare, jak i nowe klucze są ważne. Warstwa obsługi błędów rośnie proporcjonalnie — kod produkcyjny wymaga odrębnych bloków przechwytywania dla StatusCode.PermissionDenied, StatusCode.ResourceExhausted, StatusCode.Unavailable i StatusCode.DeadlineExceeded.

Podejście IronOCR

Konfiguracja IronOCR polega na wprowadzeniu ciągu znaków klucza licencyjnego. Brak plików do wdrożenia, brak zmiennych środowiskowych poza samym kluczem, brak harmonogramu rotacji:

public IronOcrCredentialSetup()
{
    // Simple license key - no key files, no environment variables required
    IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")
        ?? "YOUR-LICENSE-KEY";

    // Nie service accounts, no key rotation, no IAM configuration
    _ocr = new IronTesseract();
}

public IronOcrCredentialSetup()
{
    // Simple license key - no key files, no environment variables required
    IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")
        ?? "YOUR-LICENSE-KEY";

    // Nie service accounts, no key rotation, no IAM configuration
    _ocr = new IronTesseract();
}

Public Sub New()
    ' Simple license key - no key files, no environment variables required
    IronOcr.License.LicenseKey = If(Environment.GetEnvironmentVariable("IRONOCR_LICENSE"), "YOUR-LICENSE-KEY")

    ' Nie service accounts, no key rotation, no IAM configuration
    _ocr = New IronTesseract()
End Sub

W CI/CD klucz licencyjny jest pojedynczym sekretem potoku. W Dockerze jest to pojedyncza zmienna środowiskowa. Nie ma pliku JSON do zamontowania, nie ma roli IAM do przypisania, nie ma konsoli GCP, z którą można by współpracować. Kiedy programista dołącza do zespołu, otrzymuje jeden ciąg znaków. Pełny zakres błędów związanych z uwierzytelnianiem to: klucz jest nieprawidłowy lub okres próbny wygasł.

Podejście Google Cloud Vision

Kompletny przepływ przetwarzania PDF od google-cloud-vision-migration-examples.cs obejmuje ponad 40 linii przed implementacją DownloadAndParseResultsAsync — co samo w sobie wymaga parsowania URI wyjściowych GCS, listowania obiektów wyników, pobierania plików JSON i łączenia tekstu przez strony:

public async Task<string> ProcessPdfAsync(string pdfPath)
{
    // Step 1: Create storage client
    var storageClient = StorageClient.Create();
    var objectName = $"ocr-input/{Guid.NewGuid()}.pdf";

    // Step 2: Upload PDF to GCS (document leaves your infrastructure)
    using (var stream = File.OpenRead(pdfPath))
    {
        await storageClient.UploadObjectAsync(
            _bucketName, objectName, "application/pdf", stream);
    }

    // Step 3: Build async annotation request
    var asyncRequest = new AsyncAnnotateFileRequest
    {
        InputConfig = new InputConfig
        {
            GcsSource = new GcsSource { Uri = $"gs://{_bucketName}/{objectName}" },
            MimeType = "application/pdf"
        },
        Features = { new Funkcja { Type = Feature.Types.Type.DocumentTextDetection } },
        OutputConfig = new OutputConfig
        {
            GcsDestination = new GcsDestination { Uri = $"gs://{_bucketName}/ocr-output/" },
            BatchSize = 1
        }
    };

    // Step 4: Submit and wait for async operation
    var operation = await _visionClient.AsyncBatchAnnotateFilesAsync(
        new[] { asyncRequest });
    var completedOperation = await operation.PollUntilCompletedAsync();

    // Step 5: Download and parse results from GCS output
    var outputUri = completedOperation.Result.Responses[0]
        .OutputConfig.GcsDestination.Uri;
    var text = await DownloadAndParseResultsAsync(storageClient, outputUri);

    // Step 6: Clean up input file from GCS
    await storageClient.DeleteObjectAsync(_bucketName, objectName);

    return text;
}

public async Task<string> ProcessPdfAsync(string pdfPath)
{
    // Step 1: Create storage client
    var storageClient = StorageClient.Create();
    var objectName = $"ocr-input/{Guid.NewGuid()}.pdf";

    // Step 2: Upload PDF to GCS (document leaves your infrastructure)
    using (var stream = File.OpenRead(pdfPath))
    {
        await storageClient.UploadObjectAsync(
            _bucketName, objectName, "application/pdf", stream);
    }

    // Step 3: Build async annotation request
    var asyncRequest = new AsyncAnnotateFileRequest
    {
        InputConfig = new InputConfig
        {
            GcsSource = new GcsSource { Uri = $"gs://{_bucketName}/{objectName}" },
            MimeType = "application/pdf"
        },
        Features = { new Funkcja { Type = Feature.Types.Type.DocumentTextDetection } },
        OutputConfig = new OutputConfig
        {
            GcsDestination = new GcsDestination { Uri = $"gs://{_bucketName}/ocr-output/" },
            BatchSize = 1
        }
    };

    // Step 4: Submit and wait for async operation
    var operation = await _visionClient.AsyncBatchAnnotateFilesAsync(
        new[] { asyncRequest });
    var completedOperation = await operation.PollUntilCompletedAsync();

    // Step 5: Download and parse results from GCS output
    var outputUri = completedOperation.Result.Responses[0]
        .OutputConfig.GcsDestination.Uri;
    var text = await DownloadAndParseResultsAsync(storageClient, outputUri);

    // Step 6: Clean up input file from GCS
    await storageClient.DeleteObjectAsync(_bucketName, objectName);

    return text;
}

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

Public Class PdfProcessor
    Private _bucketName As String
    Private _visionClient As VisionClient

    Public Async Function ProcessPdfAsync(pdfPath As String) As Task(Of String)
        ' Step 1: Create storage client
        Dim storageClient = StorageClient.Create()
        Dim objectName = $"ocr-input/{Guid.NewGuid()}.pdf"

        ' Step 2: Upload PDF to GCS (document leaves your infrastructure)
        Using stream = File.OpenRead(pdfPath)
            Await storageClient.UploadObjectAsync(_bucketName, objectName, "application/pdf", stream)
        End Using

        ' Step 3: Build async annotation request
        Dim asyncRequest = New AsyncAnnotateFileRequest With {
            .InputConfig = New InputConfig With {
                .GcsSource = New GcsSource With {.Uri = $"gs://{_bucketName}/{objectName}"},
                .MimeType = "application/pdf"
            },
            .Features = {New Feature With {.Type = Feature.Types.Type.DocumentTextDetection}},
            .OutputConfig = New OutputConfig With {
                .GcsDestination = New GcsDestination With {.Uri = $"gs://{_bucketName}/ocr-output/"},
                .BatchSize = 1
            }
        }

        ' Step 4: Submit and wait for async operation
        Dim operation = Await _visionClient.AsyncBatchAnnotateFilesAsync({asyncRequest})
        Dim completedOperation = Await operation.PollUntilCompletedAsync()

        ' Step 5: Download and parse results from GCS output
        Dim outputUri = completedOperation.Result.Responses(0).OutputConfig.GcsDestination.Uri
        Dim text = Await DownloadAndParseResultsAsync(storageClient, outputUri)

        ' Step 6: Clean up input file from GCS
        Await storageClient.DeleteObjectAsync(_bucketName, objectName)

        Return text
    End Function

    Private Async Function DownloadAndParseResultsAsync(storageClient As StorageClient, outputUri As String) As Task(Of String)
        ' Implementation for downloading and parsing results
        Return Await Task.FromResult(String.Empty)
    End Function
End Class

Public Class StorageClient
    Public Shared Function Create() As StorageClient
        Return New StorageClient()
    End Function

    Public Async Function UploadObjectAsync(bucketName As String, objectName As String, mimeType As String, stream As Stream) As Task
        ' Implementation for uploading object
        Await Task.CompletedTask
    End Function

    Public Async Function DeleteObjectAsync(bucketName As String, objectName As String) As Task
        ' Implementation for deleting object
        Await Task.CompletedTask
    End Function
End Class

Public Class VisionClient
    Public Async Function AsyncBatchAnnotateFilesAsync(requests As AsyncAnnotateFileRequest()) As Task(Of Operation)
        ' Implementation for async batch annotate files
        Return Await Task.FromResult(New Operation())
    End Function
End Class

Public Class Operation
    Public Async Function PollUntilCompletedAsync() As Task(Of OperationResult)
        ' Implementation for polling until completed
        Return Await Task.FromResult(New OperationResult())
    End Function
End Class

Public Class OperationResult
    Public Property Responses As Response()
End Class

Public Class Response
    Public Property OutputConfig As OutputConfig
End Class

Public Class AsyncAnnotateFileRequest
    Public Property InputConfig As InputConfig
    Public Property Features As Feature()
    Public Property OutputConfig As OutputConfig
End Class

Public Class InputConfig
    Public Property GcsSource As GcsSource
    Public Property MimeType As String
End Class

Public Class GcsSource
    Public Property Uri As String
End Class

Public Class Feature
    Public Property Type As Feature.Types.Type

    Public Class Types
        Public Enum Type
            DocumentTextDetection
        End Enum
    End Class
End Class

Public Class OutputConfig
    Public Property GcsDestination As GcsDestination
    Public Property BatchSize As Integer
End Class

Public Class GcsDestination
    Public Property Uri As String
End Class

Jest to minimalna wersja robocza, a nie wersja gotowa do wdrożenia w środowisku produkcyjnym. Kod produkcyjny dodaje logikę ponownych prób w przypadku niepowodzeń przesyłania do GCS, obsługę limitów czasu dla powolnych operacji asynchronicznych, czyszczenie obiektów wyjściowych (nie tylko obiektów wejściowych), obsługę błędów w przypadku niepowodzenia operacji w trakcie jej wykonywania oraz rejestrowanie stanów pośrednich. Pliki PDF chronione hasłem nie są obsługiwane niezależnie od poziomu złożoności.

Podejście IronOCR

Obsługa plików PDF w IronOCR polega na bezpośrednim wczytaniu pliku i przetwarzaniu go w trybie synchronicznym:

public string ProcessPdf(string pdfPath)
{
    // Direct Przetwarzanie plików PDF - no GCS, no async, no cleanup
    using var input = new OcrInput();
    input.LoadPdf(pdfPath);
    return _ocr.Read(input).Text;
}

public string ProcessPdfPages(string pdfPath, int startPage, int endPage)
{
    // Process specific page range
    using var input = new OcrInput();
    input.LoadPdfPages(pdfPath, startPage, endPage);
    return _ocr.Read(input).Text;
}

public string ProcessEncryptedPdf(string pdfPath, string password)
{
    // Password-protected PDFs - not possible with Google Cloud Vision
    using var input = new OcrInput();
    input.LoadPdf(pdfPath, Password: password);
    return _ocr.Read(input).Text;
}

public string ProcessPdf(string pdfPath)
{
    // Direct Przetwarzanie plików PDF - no GCS, no async, no cleanup
    using var input = new OcrInput();
    input.LoadPdf(pdfPath);
    return _ocr.Read(input).Text;
}

public string ProcessPdfPages(string pdfPath, int startPage, int endPage)
{
    // Process specific page range
    using var input = new OcrInput();
    input.LoadPdfPages(pdfPath, startPage, endPage);
    return _ocr.Read(input).Text;
}

public string ProcessEncryptedPdf(string pdfPath, string password)
{
    // Password-protected PDFs - not possible with Google Cloud Vision
    using var input = new OcrInput();
    input.LoadPdf(pdfPath, Password: password);
    return _ocr.Read(input).Text;
}

Imports System

Public Class PdfProcessor
    Public Function ProcessPdf(pdfPath As String) As String
        ' Direct Przetwarzanie plików PDF - no GCS, no async, no cleanup
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)
            Return _ocr.Read(input).Text
        End Using
    End Function

    Public Function ProcessPdfPages(pdfPath As String, startPage As Integer, endPage As Integer) As String
        ' Process specific page range
        Using input As New OcrInput()
            input.LoadPdfPages(pdfPath, startPage, endPage)
            Return _ocr.Read(input).Text
        End Using
    End Function

    Public Function ProcessEncryptedPdf(pdfPath As String, password As String) As String
        ' Password-protected PDFs - not possible with Google Cloud Vision
        Using input As New OcrInput()
            input.LoadPdf(pdfPath, Password:=password)
            Return _ocr.Read(input).Text
        End Using
    End Function
End Class

Brak drugiego pakietu NuGet. Nie ma potrzeby tworzenia ani utrzymywania zasobnika GCS. Brak etapu czyszczenia. Brak asynchronicznej maszyny stanów. Wariant chroniony hasłem dodaje dokładnie jeden parametr. Dla zespołów, które muszą tworzyć przeszukiwalne PDFy z zeskanowanego wejścia, result.SaveAsSearchablePdf("output.pdf") obsługuje wyjście przeszukiwalnego PDF w jednej dodatkowej linii — coGoogle Cloud Visionnie oferuje na żadnym poziomie złożoności API.

Podejście Google Cloud Vision

Wyodrębnianie tekstu akapitu z gęstego dokumentu wymaga przejścia przez strony, następnie bloki, a potem akapity, a na końcu połączenia symboli z każdego WORD-a — ponieważ projekt Protobuf przechowuje tekst na poziomie symboli, a nie słów czy akapitów:

public DocumentStructure ExtractDocumentStructure(string imagePath)
{
    var image = Image.FromFile(imagePath);
    var annotation = _client.DetectDocumentText(image);

    var structure = new DocumentStructure
    {
        FullText = annotation.Text,
        Pages = new List<PageInfo>()
    };

    // Navigate: Pages -> Blocks -> Paragraphs -> Words -> Symbols
    foreach (var page in annotation.Pages)
    {
        var pageInfo = new PageInfo
        {
            Confidence = page.Confidence,
            Paragraphs = new List<ParagraphInfo>()
        };

        foreach (var block in page.Blocks)
        {
            foreach (var paragraph in block.Paragraphs)
            {
                // Must concatenate symbols to get paragraph text
                var text = string.Join("", paragraph.Words
                    .SelectMany(w => w.Symbols)
                    .Select(s => s.Text));

                pageInfo.Paragraphs.Add(new ParagraphInfo
                {
                    Text = text,
                    Confidence = paragraph.Confidence
                });
            }
        }
        structure.Pages.Add(pageInfo);
    }

    return structure;
}

public DocumentStructure ExtractDocumentStructure(string imagePath)
{
    var image = Image.FromFile(imagePath);
    var annotation = _client.DetectDocumentText(image);

    var structure = new DocumentStructure
    {
        FullText = annotation.Text,
        Pages = new List<PageInfo>()
    };

    // Navigate: Pages -> Blocks -> Paragraphs -> Words -> Symbols
    foreach (var page in annotation.Pages)
    {
        var pageInfo = new PageInfo
        {
            Confidence = page.Confidence,
            Paragraphs = new List<ParagraphInfo>()
        };

        foreach (var block in page.Blocks)
        {
            foreach (var paragraph in block.Paragraphs)
            {
                // Must concatenate symbols to get paragraph text
                var text = string.Join("", paragraph.Words
                    .SelectMany(w => w.Symbols)
                    .Select(s => s.Text));

                pageInfo.Paragraphs.Add(new ParagraphInfo
                {
                    Text = text,
                    Confidence = paragraph.Confidence
                });
            }
        }
        structure.Pages.Add(pageInfo);
    }

    return structure;
}

Imports System.Drawing

Public Function ExtractDocumentStructure(imagePath As String) As DocumentStructure
    Dim image = Image.FromFile(imagePath)
    Dim annotation = _client.DetectDocumentText(image)

    Dim structure As New DocumentStructure With {
        .FullText = annotation.Text,
        .Pages = New List(Of PageInfo)()
    }

    ' Navigate: Pages -> Blocks -> Paragraphs -> Words -> Symbols
    For Each page In annotation.Pages
        Dim pageInfo As New PageInfo With {
            .Confidence = page.Confidence,
            .Paragraphs = New List(Of ParagraphInfo)()
        }

        For Each block In page.Blocks
            For Each paragraph In block.Paragraphs
                ' Must concatenate symbols to get paragraph text
                Dim text = String.Join("", paragraph.Words _
                    .SelectMany(Function(w) w.Symbols) _
                    .Select(Function(s) s.Text))

                pageInfo.Paragraphs.Add(New ParagraphInfo With {
                    .Text = text,
                    .Confidence = paragraph.Confidence
                })
            Next
        Next
        structure.Pages.Add(pageInfo)
    Next

    Return structure
End Function

Konkatenacja na poziomie symboli nie jest opcjonalna — paragraph.Text nie istnieje jako bezpośrednia właściwość w odpowiedzi Protobuf. Każdy zespół korzystający z tego API pisze własną wersję tej samej agregacji w pętli zagnieżdżonej. Pewność na poziomie słów wymaga szóstego poziomu iteracji w celu uzyskania wartości word.Confidence, a następnie zmapowania ich z powrotem do wyniku łączenia symboli.

Podejście IronOCR

IronOCR's OcrResult exposes a flat, typed API. Pages, Paragraphs, Lines i Words są wszystkimi bezpośrednimi właściwościami z Text, Confidence, X, Y, Width i Height gotowymi do użytku:

public DocumentStructure ExtractDocumentStructure(string imagePath)
{
    var result = _ocr.Read(imagePath);

    // Direct access - no symbol concatenation, no nested loops
    return new DocumentStructure
    {
        FullText = result.Text,
        Confidence = result.Confidence,
        Paragraphs = result.Paragraphs.Select(p => new ParagraphInfo
        {
            Text = p.Text,
            Confidence = p.Confidence
        }).ToList(),
        Lines = result.Lines.Select(l => new LineInfo
        {
            Text = l.Text,
            X = l.X,
            Y = l.Y
        }).ToList()
    };
}

public DocumentStructure ExtractDocumentStructure(string imagePath)
{
    var result = _ocr.Read(imagePath);

    // Direct access - no symbol concatenation, no nested loops
    return new DocumentStructure
    {
        FullText = result.Text,
        Confidence = result.Confidence,
        Paragraphs = result.Paragraphs.Select(p => new ParagraphInfo
        {
            Text = p.Text,
            Confidence = p.Confidence
        }).ToList(),
        Lines = result.Lines.Select(l => new LineInfo
        {
            Text = l.Text,
            X = l.X,
            Y = l.Y
        }).ToList()
    };
}

Public Function ExtractDocumentStructure(imagePath As String) As DocumentStructure
    Dim result = _ocr.Read(imagePath)

    ' Direct access - no symbol concatenation, no nested loops
    Return New DocumentStructure With {
        .FullText = result.Text,
        .Confidence = result.Confidence,
        .Paragraphs = result.Paragraphs.Select(Function(p) New ParagraphInfo With {
            .Text = p.Text,
            .Confidence = p.Confidence
        }).ToList(),
        .Lines = result.Lines.Select(Function(l) New LineInfo With {
            .Text = l.Text,
            .X = l.X,
            .Y = l.Y
        }).ToList()
    }
End Function

Przewodnik po wynikach odczytu obejmuje pełny interfejs API danych strukturalnych. Pozycjonowanie i wyniki pewności na poziomie słów są dostępne na result.Words[i].X, result.Words[i].Y i result.Words[i].Confidence bez nawigowania po pośredniej hierarchii. Dla ekstrakcji specyficznej dla regionu, OCR na podstawie regionu używa CropRectangle na OcrInput, co unika przetwarzania całego obrazu, gdy potrzebny jest tylko wiersz nagłówka lub określone pole.

Podejście Google Cloud Vision

CenyGoogle Cloud Visionsą oparte na wykorzystaniu i różnią się w zależności od typu funkcji i objętości. Zapoznaj się ze stroną cen Google Cloud Vision w celu uzyskania aktualnych stawek. Należy zauważyć, że całkowite koszty mogą również obejmować opłaty za przechowywanie GCS i opłaty operacyjne dla przepływów pracy PDF, koszty wyjścia sieciowego oraz czas wygospodarowany na zarządzanie poświadczeniami i rotacje kluczy.

Przy wysokich objętościach dokumentów, opłaty za obraz kumulują się znacząco, z kosztami rosnącymi liniowo z objętością i bez limitu, chyba że zostanie wynegocjowana umowa na zobowiązane użytkowanie.

Podejście IronOCR

Ceny IronOCR to jednorazowy zakup wieczysty: $999 Lite (1 deweloper), $1,499 Plus (3 deweloperów), $2,999 Professional (10 deweloperów), $5,999 Unlimited. Licencja obejmuje nieograniczone przetwarzanie dokumentów bez pomiaru. Drugi rok jest bezpłatny. Trzeci rok jest bezpłatny. Przy wysokich objętościach dokumentów, wieczysta licencja IronOCR szybko staje się bardziej opłacalna niż ceny w chmurze za obraz. Zobacz stronę licencji IronOCR dla aktualnych szczegółów poziomu.

Punkt przecięcia, w którym IronOCR staje się tańszy od Google Cloud Vision, zależy od twojego wolumenu i obecnych cen Google. Dla większości zespołów przetwarzających dokumenty konsekwentnie w produkcji, wieczysta licencja IronOCR zwraca się w ciągu kilku pierwszych miesięcy użytkowania.

Wymagania dotyczące zgodności Przetwarzanie w chmurze

Najczęstszym czynnikiem skłaniającym do migracji nie są koszty — jest to audyt zgodności. Wykonawcy rządowi napotykają ograniczenia wynikające z przepisów ITAR i dowiadują się, że przesyłanie danych technicznych podlegających kontroli do Google Cloud jest zabronione. Organizacje opieki zdrowotnej tworzące procesy przetwarzania dokumentów stwierdzają, że ich inspektor ds. bezpieczeństwa HIPAA wymaga przeglądu umowy o współpracy biznesowej (Business Associate Agreement) każdego podmiotu przetwarzającego dane, a ocena zakresu infrastruktury chmurowej Google przekracza ich tolerancję ryzyka. Działy prawne zajmujące się przetwarzaniem poufnych dokumentów klientów uznają, że kwestie związane z tajemnicą adwokacką przeważają nad wygodą przetwarzania w chmurze. Wykonawcy z sektóra obronnego muszą spełniać wymagania CMMC, które traktują wszelkie dane opuszczające granice organizacji jako naruszenie. We wszystkich tych scenariuszach jakość techniczna modeli ML firmy Google nie ma znaczenia — to sama architektura stanowi czynnik dyskwalifikujący. Model lokalny IronOCR eliminuje całą kategorię zgodności z przepisami dotyczącymi przetwarzania danych przez podmioty zewnętrzne, ponieważ w przetwarzaniu nie bierze udziału żadna strona trzecia.

Przepływy pracy z plikami PDF stają się niemożliwe do zarządzania na dużą skalę

Zespoły, które zaczynają korzystać zGoogle Cloud Visiondo OCR obrazów, często odkrywają złożoność plików PDF, gdy muszą rozszerzyć zakres swoich działań. Obsługa 200 plików PDF dziennie za pomocą asynchronicznego potoku GCS jest wykonalna, ale uciążliwa. Obsługa 10 000 plików PDF dziennie wymaga wzmocnienia całego procesu: logiki ponownych prób w przypadku niepowodzeń przesyłania do GCS, kolejek nieodebranych wiadomości dla operacji, które nigdy nie zostały zakończone, zadań czyszczenia osieroconych obiektów GCS w przypadku awarii aplikacji w trakcie procesu oraz monitorowania zarówno kosztów Vision API, jak i kosztów przechowywania w GCS. Zespoły, które osiągają tę skalę, konsekwentnie uznają migrację do IronOCR za prostą — cały asynchroniczny potok GCS sprowadza się do bezpośredniego wczytania pliku lokalnego, po którym następuje pojedyncze wywołanie odczytu, a tryby awarii ograniczają się wyłącznie do wyjątków wejścia/wyjścia plików lokalnych, zamiast obejmować przekroczenia limitów czasu sieci, błędy uwierzytelniania, błędy limitu GCS i wyjątki parsowania JSON.

Przewidywalność budżetu jest ważniejsza niż elastyczność w przeliczeniu na pojedynczy obraz

Projekty na wczesnym etapie często wybierają Google Cloud Vision, ponieważ bezpłatny pakiet pokrywa początkowe koszty rozwoju, a model rozliczeniowy oparty na liczbie obrazów sprowadza się do zera, gdy nic nie jest przetwarzane. Gdy produkt osiąga stałą wielkość produkcji — zazwyczaj powyżej 50 000 dokumentów miesięcznie — zespół finansowy zauważa powtarzającą się pozycję w zestawieniu. W przeciwieństwie do subskrypcji SaaS, które rosną wraz z rozwojem firmy, Licencja wieczysta IronOCR przekształca OCR ze zmiennego kosztu operacyjnego w stały wydatek kapitałowy. Dla zespołu 10 deweloperów przetwarzających dokumenty w regulowanym przemyśle, licencja Professional za $2,999 jednorazowo zazwyczaj uzasadnia się w pierwszym kwartale wolumenu produkcji w porównaniu do bieżących kosztów za obraz w chmurze.

Przetwarzanie wsadowe osiąga limity częstotliwości

Procesy wymagające przetwarzania dużej ilości dokumentów — ujawnianie informacji prawnych, digitalizacja dokumentów finansowych, przetwarzanie roszczeń ubezpieczeniowych — rutynowo wymagają przetwarzania tysięcy dokumentów na godzinę. Domyślny limit 1800 żądań na minutę wGoogle Cloud Visionoznacza, że wysyłanie 3000 dokumentów w krótkim czasie uruchamia ograniczenie szybkości i wymaga albo złożenia wniosku o zwiększenie limitu przez konsolę GCP (co wiąże się z oczekiwaniem na zatwierdzenie przez Google), albo wdrożenia algorytmu wykładniczego cofania z jitterem. Pojedyncze przekroczenie limitu powoduje zatrzymanie całego procesu przetwarzania i obowiązkowe 60-sekundowe oczekiwanie przed ponowną próbą. Lokalne przetwarzanie w IronOCR jest ograniczone jedynie dostępnymi rdzeniami procesora, a przetwarzanie równoległe wykorzystuje je wszystkie bez konieczności uzyskania zewnętrznej zgody.

Wymagane są wdrożenia typu air-gapped

Niektóre środowiska z założenia nie mają połączenia z internetem: tajne sieci wojskowe, przemysłowe systemy sterowania, bezpieczne centra danych do rozliczeń finansowych.Google Cloud Visionnie może funkcjonować w tych środowiskach na żadnym poziomie kreatywności architektonicznej — API wymaga połączenia internetowego z punktami końcowymi Google. WdrożenieIronOCRw Dockerze działa bez połączenia z internetem. Klucz licencyjny jest weryfikowany przy pierwszym użyciu i zapisywany w pamięci podręcznej; Dalsze korzystanie nie wymaga dostępu do sieci.

Usunięcie zależności od GCS

Najważniejszą zmianą strukturalną podczas migracji jest całkowite wyeliminowanie potoku GCS. Przed usunięciem pakietów Google należy udokumentować każdy zasób GCS utworzony na potrzeby wejścia i wyjścia OCR, a następnie je wyczyścić, aby uniknąć bieżących opłat za przechowywanie. Zmienna środowiskowa GOOGLE_APPLICATION_CREDENTIALS i plik klucza JSON powinny być usunięte ze wszystkich konfiguracji wdrożeniowych, sekretów CI/CD i maszyn deweloperskich. Konto usługi IAM w konsoli GCP można wyłączyć lub usunąć po upewnieniu się, że żadne inne usługi nie są od niego zależne.

Po usunięciu Google.Cloud.Vision.V1 i Google.Cloud.Storage.V1, kod przetwarzania PDF, który wcześniej obejmował ponad 50 linii asynchronicznej orkiestracji, redukuje się do OcrInput z LoadPdf i pojedynczym wywołaniem Read. Zmiana zasad obsługi błędów: znikają wyjątki sieciowe, wyjątki autoryzacji i wyjątki ograniczeń szybkości. Pozostałe wyjątki to wyjątki we/wy plików (plik nie znaleziony, plik zablokowany) i OcrException dla niepowodzeń przetwarzania. Przewodnik po wprowadzaniu obrazów IronOCR oraz przewodnik po wprowadzaniu plików PDF obejmują pełny interfejs API wprowadzania danych, w tym strumienie, tablice bajtów i ładowanie adresów URL.

Łączenie symboli Protobuf w celu uzyskania bezpośredniego dostępu do tekstu

Każda lokalizacja w Twojej bazie kodu, gdzie napisałeś .SelectMany(w => w.Symbols).Select(s => s.Text), aby wyodrębnić tekst akapitu lub słowa z hierarchii Protobuf, staje się bezpośrednim dostępem do właściwości. paragraph.Text, line.Text i word.Text istnieją jako typowe właściwości łańcuchowe na obiektach wynikowych IronOCR. Przejrzyj cały kod służący do pozyskiwania danych strukturalnych i usuń pośrednią logikę agregacji. Przewodnik jak czytać wyniki mapuje każdą właściwość dostępną na OcrResult, OcrResult.Page, OcrResult.Paragraph, OcrResult.Line i OcrResult.Word.

Przejście z trybu asynchronicznego do synchronicznego w przepływach pracy z plikami PDF

Przetwarzanie plików PDF wGoogle Cloud Visionodbywa się wyłącznie w trybie asynchronicznym, ponieważ operacja ta wymaga komunikacji z GCS. Metoda ReadIronOCR jest synchroniczna. Jeśli warstwa przetwarzania PDF w Twojej aplikacji jest zbudowana wokół sygnatur async Task<string> i łańcuchów wywołań opartych na await, wzorzec migracji to Task.Run wrapper:

public async Task<string> ProcessPdfAsync(string pdfPath)
{
    return await Task.Run(() =>
    {
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    });
}

public async Task<string> ProcessPdfAsync(string pdfPath)
{
    return await Task.Run(() =>
    {
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    });
}

Imports System.Threading.Tasks

Public Async Function ProcessPdfAsync(pdfPath As String) As Task(Of String)
    Return Await Task.Run(Function()
                              Using input As New OcrInput()
                                  input.LoadPdf(pdfPath)
                                  Return _ocr.Read(input).Text
                              End Using
                          End Function)
End Function

Pozwala to zachować interfejs asynchroniczny dla wywołujących podczas wykonywania operacji OCR w puli wątków. Dla scenariuszy o wysokiej przepustowości, wbudowane asynchroniczne wsparcie OCRIronOCR obsługuje ten wzorzec natywnie bez wrappera Task.Run.

Przetwarzanie wstępne obrazów obsługiwanych przez system uczenia maszynowego Google

Modele oparte na uczeniu maszynowym wGoogle Cloud Visionradzą sobie z niektórymi problemami związanymi z jakością obrazu — niskim kontrastem, niewielkim przekrzywieniem, umiarkowanym szumem — bez konieczności wyraźnej konfiguracji przetwarzania wstępnego. Silniki oparte na Tesseract, w tym IronOCR, korzystają z jawnego przetwarzania wstępnego w przypadku danych wejściowych o obniżonej jakości. Jeśli Twoja baza dokumentów zawiera niskiej jakości skany, dodaj input.Deskew(), input.DeNoise() i input.EnhanceResolution(300) do potoku wejściowego. Automatyczne przetwarzanie wstępne IronOCR stosuje te filtry inteligentnie przy wykrywaniu problemów z jakością obrazu, ale dla znanych problemowych źródeł skanowania, eksplicitne zastosowanie filtru daje deterministyczne wyniki. Przewodnik po korekcji jakości obrazu obejmuje pełny interfejs API filtrów, a przewodnik po korekcji kolorów obrazu dotyczy kontrastu i binarizacji skanów o nierównomiernym oświetleniu.