IronOCR 사용한 Acrobat DC OCR 대체 프로그램

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

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

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

    // 아니요 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")

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

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기능{ 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 of 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 of uploading object
        Await Task.CompletedTask
    End Function

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

Public Class VisionClient
    Public Async Function AsyncBatchAnnotateFilesAsync(requests As AsyncAnnotateFileRequest()) As Task(Of Operation)
        ' Implementation of 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 of 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 List(Of Feature) = New List(Of 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 Class Types
        Public Enum Type
            DocumentTextDetection
        End Enum
    End Class

    Public Property Type As Types.Type
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

public string ProcessPdf(string pdfPath)
{
    // DirectPDF 처리- 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;
}

Option Strict On



Public Function ProcessPdf(ByVal pdfPath As String) As String
    ' DirectPDF 처리- 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(ByVal pdfPath As String, ByVal startPage As Integer, ByVal 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(ByVal pdfPath As String, ByVal 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

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

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

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