AWS vs Google Vision (Porównanie funkcji OCR)

using Dynamsoft.DLR;

public class DynamsoftMrzService : IDisposable
{
    private readonly LabelRecognizer _recognizer;

    public DynamsoftMrzService(string licenseKey)
    {
        // Static license initialization — must precede instance creation
        LabelRecognizer.InitLicense(licenseKey);
        _recognizer = new LabelRecognizer();

        // MRZ requires specific template configuration loaded as JSON
        string mrzTemplate = @"{
            ""LabelRecognizerParameterArray"": [{
                ""Name"": ""MRZ"",
                ""ReferenceRegionNameArray"": [""FullImage""],
                ""CharacterModelName"": ""MRZ""
            }]
        }";
        _recognizer.AppendSettingsFromString(mrzTemplate);
    }

    public string ExtractRawMrz(string passportImagePath)
    {
        var results = _recognizer.RecognizeFile(passportImagePath);

        // Returns raw MRZ text lines only — no field parsing
        var mrzLines = new StringBuilder();
        foreach (var result in results)
        {
            foreach (var lineResult in result.LineResults)
            {
                mrzLines.AppendLine(lineResult.Text);
            }
        }
        return mrzLines.ToString().Trim();
    }

    public void Dispose() => _recognizer?.Dispose();
}

Imports Dynamsoft.DLR
Imports System.Text

Public Class DynamsoftMrzService
    Implements IDisposable

    Private ReadOnly _recognizer As LabelRecognizer

    Public Sub New(licenseKey As String)
        ' Static license initialization — must precede instance creation
        LabelRecognizer.InitLicense(licenseKey)
        _recognizer = New LabelRecognizer()

        ' MRZ requires specific template configuration loaded as JSON
        Dim mrzTemplate As String = "{
            ""LabelRecognizerParameterArray"": [{
                ""Name"": ""MRZ"",
                ""ReferenceRegionNameArray"": [""FullImage""],
                ""CharacterModelName"": ""MRZ""
            }]
        }"
        _recognizer.AppendSettingsFromString(mrzTemplate)
    End Sub

    Public Function ExtractRawMrz(passportImagePath As String) As String
        Dim results = _recognizer.RecognizeFile(passportImagePath)

        ' Returns raw MRZ text lines only — no field parsing
        Dim mrzLines As New StringBuilder()
        For Each result In results
            For Each lineResult In result.LineResults
                mrzLines.AppendLine(lineResult.Text)
            Next
        Next
        Return mrzLines.ToString().Trim()
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _recognizer?.Dispose()
    End Sub
End Class

// Dynamsoft passport processing — MULTIPLE PRODUCTS REQUIRED

using Dynamsoft.DLR;  // Label Recognizer — for MRZ (annual subscription)
using Dynamsoft.DBR;  // Barcode Reader — for any barcodes (additional license)
// Plus: a separate OCR library — for full page text (more budget)

public class DynamsoftPassportProcessor : IDisposable
{
    private readonly LabelRecognizer _mrzRecognizer;
    private readonly BarcodeReader _barcodeReader;
    // private readonly SomeOtherOcrLibrary _fullTextOcr;  // third product

    public DynamsoftPassportProcessor(
        string mrzLicenseKey,
        string barcodeLicenseKey)
    {
        // License each product independently
        LabelRecognizer.InitLicense(mrzLicenseKey);
        _mrzRecognizer = new LabelRecognizer();

        // Configure MRZ template — JSON required before any recognition
        string mrzTemplate = @"{
            ""LabelRecognizerParameterArray"": [{
                ""Name"": ""MRZ_Passport"",
                ""ReferenceRegionNameArray"": [""FullImage""],
                ""CharacterModelName"": ""MRZ""
            }]
        }";
        _mrzRecognizer.AppendSettingsFromString(mrzTemplate);

        // Second product, second license key
        BarcodeReader.InitLicense(barcodeLicenseKey);
        _barcodeReader = new BarcodeReader();
    }

    public PassportResult ProcessPassport(string imagePath)
    {
        // Step 1: Wyodrębnianie MRZ — raw text only, no field parsing
        var mrzResults = _mrzRecognizer.RecognizeFile(imagePath);
        var mrzText = new StringBuilder();
        foreach (var r in mrzResults)
            foreach (var line in r.LineResults)
                mrzText.AppendLine(line.Text);

        // Step 2: Parse MRZ manually — your 150-line TD3 parser here
        var parsedMrz = ParseMrzManually(mrzText.ToString());

        // Step 3: Barcodes — second product, second API
        var barcodeResults = _barcodeReader.DecodeFile(imagePath);

        // Step 4: Full page text — THIRD library, no Dynamsoft option
        // var fullText = _fullTextOcr.ReadImage(imagePath);

        return new PassportResult
        {
            ParsedMrz = parsedMrz,
            Barcodes = barcodeResults.Select(b => b.BarcodeText).ToList(),
            FullPageText = null  // requires a fourth product
        };
    }

    public void Dispose()
    {
        _mrzRecognizer?.Dispose();
        _barcodeReader?.Dispose();
    }
}

Imports Dynamsoft.DLR  ' Label Recognizer — for MRZ (annual subscription)
Imports Dynamsoft.DBR  ' Barcode Reader — for any barcodes (additional license)
' Plus: a separate OCR library — for full page text (more budget)

Public Class DynamsoftPassportProcessor
    Implements IDisposable

    Private ReadOnly _mrzRecognizer As LabelRecognizer
    Private ReadOnly _barcodeReader As BarcodeReader
    ' Private ReadOnly _fullTextOcr As SomeOtherOcrLibrary  ' third product

    Public Sub New(mrzLicenseKey As String, barcodeLicenseKey As String)
        ' License each product independently
        LabelRecognizer.InitLicense(mrzLicenseKey)
        _mrzRecognizer = New LabelRecognizer()

        ' Configure MRZ template — JSON required before any recognition
        Dim mrzTemplate As String = "{
            ""LabelRecognizerParameterArray"": [{
                ""Name"": ""MRZ_Passport"",
                ""ReferenceRegionNameArray"": [""FullImage""],
                ""CharacterModelName"": ""MRZ""
            }]
        }"
        _mrzRecognizer.AppendSettingsFromString(mrzTemplate)

        ' Second product, second license key
        BarcodeReader.InitLicense(barcodeLicenseKey)
        _barcodeReader = New BarcodeReader()
    End Sub

    Public Function ProcessPassport(imagePath As String) As PassportResult
        ' Step 1: Wyodrębnianie MRZ — raw text only, no field parsing
        Dim mrzResults = _mrzRecognizer.RecognizeFile(imagePath)
        Dim mrzText = New StringBuilder()
        For Each r In mrzResults
            For Each line In r.LineResults
                mrzText.AppendLine(line.Text)
            Next
        Next

        ' Step 2: Parse MRZ manually — your 150-line TD3 parser here
        Dim parsedMrz = ParseMrzManually(mrzText.ToString())

        ' Step 3: Barcodes — second product, second API
        Dim barcodeResults = _barcodeReader.DecodeFile(imagePath)

        ' Step 4: Full page text — THIRD library, no Dynamsoft option
        ' Dim fullText = _fullTextOcr.ReadImage(imagePath)

        Return New PassportResult With {
            .ParsedMrz = parsedMrz,
            .Barcodes = barcodeResults.Select(Function(b) b.BarcodeText).ToList(),
            .FullPageText = Nothing  ' requires a fourth product
        }
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _mrzRecognizer?.Dispose()
        _barcodeReader?.Dispose()
    End Sub
End Class

using IronOcr;

public class IronOcrPassportProcessor
{
    private readonly IronTesseract _ocr;

    public IronOcrPassportProcessor()
    {
        _ocr = new IronTesseract();
        _ocr.Configuration.ReadBarCodes = true;  // barcodes included
    }

    public CompletePassportResult ProcessPassport(string imagePath)
    {
        // Structured MRZ fields — no manual parsing required
        var mrzData = _ocr.ReadPassport(imagePath);

        // Full page OCR + barcodes in the same call
        var fullResult = _ocr.Read(imagePath);

        return new CompletePassportResult
        {
            // MRZ fields are already parsed properties
            DocumentType    = mrzData.DocumentType,
            IssuingCountry  = mrzData.IssuingCountry,
            Surname         = mrzData.Surname,
            GivenNames      = mrzData.GivenNames,
            PassportNumber  = mrzData.DocumentNumber,
            Nationality     = mrzData.Nationality,
            DateOfBirth     = mrzData.DateOfBirth,
            ExpiryDate      = mrzData.ExpiryDate,
            RawMrz          = mrzData.MRZ,

            // Full page text from same package
            FullPageText    = fullResult.Text,

            // Barcodes alongside text — no separate product
            Barcodes        = fullResult.Barcodes.Select(b => b.Value).ToList(),

            Confidence      = fullResult.Confidence
        };
    }
}

Imports IronOcr

Public Class IronOcrPassportProcessor
    Private ReadOnly _ocr As IronTesseract

    Public Sub New()
        _ocr = New IronTesseract()
        _ocr.Configuration.ReadBarCodes = True ' barcodes included
    End Sub

    Public Function ProcessPassport(imagePath As String) As CompletePassportResult
        ' Structured MRZ fields — no manual parsing required
        Dim mrzData = _ocr.ReadPassport(imagePath)

        ' Full page OCR + barcodes in the same call
        Dim fullResult = _ocr.Read(imagePath)

        Return New CompletePassportResult With {
            ' MRZ fields are already parsed properties
            .DocumentType = mrzData.DocumentType,
            .IssuingCountry = mrzData.IssuingCountry,
            .Surname = mrzData.Surname,
            .GivenNames = mrzData.GivenNames,
            .PassportNumber = mrzData.DocumentNumber,
            .Nationality = mrzData.Nationality,
            .DateOfBirth = mrzData.DateOfBirth,
            .ExpiryDate = mrzData.ExpiryDate,
            .RawMrz = mrzData.MRZ,

            ' Full page text from same package
            .FullPageText = fullResult.Text,

            ' Barcodes alongside text — no separate product
            .Barcodes = fullResult.Barcodes.Select(Function(b) b.Value).ToList(),

            .Confidence = fullResult.Confidence
        }
    End Function
End Class

// Dynamsoft warehouse scanner — THREE products, THREE license keys

using Dynamsoft.DLR;  // Label Recognizer — product labels
using Dynamsoft.DBR;  // Barcode Reader — product barcodes
using Dynamsoft.DDN;  // Document Normalizer — document edge detection

public class DynamsoftWarehouseScanner : IDisposable
{
    private readonly LabelRecognizer _labelRecognizer;
    private readonly BarcodeReader _barcodeReader;
    private readonly DocumentNormalizer _documentNormalizer;

    public DynamsoftWarehouseScanner(
        string labelLicenseKey,
        string barcodeLicenseKey,
        string documentLicenseKey)
    {
        LabelRecognizer.InitLicense(labelLicenseKey);
        _labelRecognizer = new LabelRecognizer();

        BarcodeReader.InitLicense(barcodeLicenseKey);
        _barcodeReader = new BarcodeReader();

        DocumentNormalizer.InitLicense(documentLicenseKey);
        _documentNormalizer = new DocumentNormalizer();
    }

    public WarehouseItemResult ScanItem(string imagePath)
    {
        // Three separate API calls, three result types to aggregate manually
        var labelResults   = _labelRecognizer.RecognizeFile(imagePath);
        var barcodeResults = _barcodeReader.DecodeFile(imagePath);
        var docResults     = _documentNormalizer.Normalize(imagePath);

        // Merge three result sets into one model — your code
        return AggregateResults(labelResults, barcodeResults, docResults);
    }

    public void Dispose()
    {
        _labelRecognizer?.Dispose();
        _barcodeReader?.Dispose();
        _documentNormalizer?.Dispose();
    }
}

Imports Dynamsoft.DLR  ' Label Recognizer — product labels
Imports Dynamsoft.DBR  ' Barcode Reader — product barcodes
Imports Dynamsoft.DDN  ' Document Normalizer — document edge detection

Public Class DynamsoftWarehouseScanner
    Implements IDisposable

    Private ReadOnly _labelRecognizer As LabelRecognizer
    Private ReadOnly _barcodeReader As BarcodeReader
    Private ReadOnly _documentNormalizer As DocumentNormalizer

    Public Sub New(labelLicenseKey As String, barcodeLicenseKey As String, documentLicenseKey As String)
        LabelRecognizer.InitLicense(labelLicenseKey)
        _labelRecognizer = New LabelRecognizer()

        BarcodeReader.InitLicense(barcodeLicenseKey)
        _barcodeReader = New BarcodeReader()

        DocumentNormalizer.InitLicense(documentLicenseKey)
        _documentNormalizer = New DocumentNormalizer()
    End Sub

    Public Function ScanItem(imagePath As String) As WarehouseItemResult
        ' Three separate API calls, three result types to aggregate manually
        Dim labelResults = _labelRecognizer.RecognizeFile(imagePath)
        Dim barcodeResults = _barcodeReader.DecodeFile(imagePath)
        Dim docResults = _documentNormalizer.Normalize(imagePath)

        ' Merge three result sets into one model — your code
        Return AggregateResults(labelResults, barcodeResults, docResults)
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _labelRecognizer?.Dispose()
        _barcodeReader?.Dispose()
        _documentNormalizer?.Dispose()
    End Sub
End Class

using IronOcr;

public class IronOcrWarehouseScanner
{
    private readonly IronTesseract _ocr;

    public IronOcrWarehouseScanner()
    {
        _ocr = new IronTesseract();
        _ocr.Configuration.ReadBarCodes = true;  // barcodes in same pass
    }

    public WarehouseItemResult ScanItem(string imagePath)
    {
        // One call: text + barcodes + structured word positions
        var result = _ocr.Read(imagePath);

        return new WarehouseItemResult
        {
            AllText    = result.Text,
            Barcodes   = result.Barcodes.Select(b => new BarcodeInfo
                         { Format = b.Format.ToString(), Value = b.Value }).ToList(),
            Confidence = result.Confidence
        };
    }

    public string ScanLabelRegion(string imagePath, int x, int y, int width, int height)
    {
        // Target a specific label area — no template JSON required
        var region = new CropRectangle(x, y, width, height);
        using var input = new OcrInput();
        input.LoadImage(imagePath, region);
        input.Deskew();
        input.Contrast();

        return _ocr.Read(input).Text;
    }

    public string ProcessShipmentPdf(string pdfPath)
    {
        // Native PDF — no external library, no page conversion loop
        return _ocr.Read(pdfPath).Text;
    }
}

Imports IronOcr

Public Class IronOcrWarehouseScanner
    Private ReadOnly _ocr As IronTesseract

    Public Sub New()
        _ocr = New IronTesseract()
        _ocr.Configuration.ReadBarCodes = True ' barcodes in same pass
    End Sub

    Public Function ScanItem(imagePath As String) As WarehouseItemResult
        ' One call: text + barcodes + structured word positions
        Dim result = _ocr.Read(imagePath)

        Return New WarehouseItemResult With {
            .AllText = result.Text,
            .Barcodes = result.Barcodes.Select(Function(b) New BarcodeInfo With {
                .Format = b.Format.ToString(),
                .Value = b.Value
            }).ToList(),
            .Confidence = result.Confidence
        }
    End Function

    Public Function ScanLabelRegion(imagePath As String, x As Integer, y As Integer, width As Integer, height As Integer) As String
        ' Target a specific label area — no template JSON required
        Dim region = New CropRectangle(x, y, width, height)
        Using input As New OcrInput()
            input.LoadImage(imagePath, region)
            input.Deskew()
            input.Contrast()

            Return _ocr.Read(input).Text
        End Using
    End Function

    Public Function ProcessShipmentPdf(pdfPath As String) As String
        ' Native PDF — no external library, no page conversion loop
        Return _ocr.Read(pdfPath).Text
    End Function
End Class

// Application startup — one line, works for all features
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

' Application startup — one line, works for all features
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

// Before: Dynamsoft raw extraction + manual 150-line parser
var results = _recognizer.RecognizeFile(imagePath);
var rawMrz = string.Join("\n", results.SelectMany(r => r.LineResults).Select(l => l.Text));
var parsed = MyTd3Parser.Parse(rawMrz);  // delete this file

// After:IronOCR parsed output directly
var passportData = new IronTesseract().ReadPassport(imagePath);
string surname  = passportData.Surname;
string docNum   = passportData.DocumentNumber;
DateTime? dob   = passportData.DateOfBirth;

Imports System
Imports System.Linq

' Before: Dynamsoft raw extraction + manual 150-line parser
Dim results = _recognizer.RecognizeFile(imagePath)
Dim rawMrz = String.Join(vbCrLf, results.SelectMany(Function(r) r.LineResults).Select(Function(l) l.Text))
Dim parsed = MyTd3Parser.Parse(rawMrz)  ' delete this file

' After: IronOCR parsed output directly
Dim passportData = New IronTesseract().ReadPassport(imagePath)
Dim surname As String = passportData.Surname
Dim docNum As String = passportData.DocumentNumber
Dim dob As DateTime? = passportData.DateOfBirth

// Before: three static initializations
LabelRecognizer.InitLicense(mrzKey);
BarcodeReader.InitLicense(barcodeKey);
DocumentNormalizer.InitLicense(documentKey);

// After: one line, all capabilities enabled
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

var ocr = new IronTesseract();
ocr.Configuration.ReadBarCodes = true;  // barcodes included automatically

Imports System

' Before: three static initializations
LabelRecognizer.InitLicense(mrzKey)
BarcodeReader.InitLicense(barcodeKey)
DocumentNormalizer.InitLicense(documentKey)

' After: one line, all capabilities enabled
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

Dim ocr As New IronTesseract()
ocr.Configuration.ReadBarCodes = True  ' barcodes included automatically

// Before: PDF rendering loop (50+ lines with external library)
var pdfDoc = PdfDocument.Load(pdfPath);
foreach (var page in pdfDoc.Pages)
{
    var bitmap = page.RenderAsBitmap(150);
    var results = _labelRecognizer.RecognizeFile(SaveBitmapToTemp(bitmap));
    // aggregate...
}

// After: native PDF — no loop, no external library
var result = new IronTesseract().Read(pdfPath);
string fullText = result.Text;
result.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

' Before: PDF rendering loop (50+ lines with external library)
Dim pdfDoc = PdfDocument.Load(pdfPath)
For Each page In pdfDoc.Pages
    Dim bitmap = page.RenderAsBitmap(150)
    Dim results = _labelRecognizer.RecognizeFile(SaveBitmapToTemp(bitmap))
    ' aggregate...
Next

' After: native PDF — no loop, no external library
Dim result = New IronTesseract().Read(pdfPath)
Dim fullText As String = result.Text
result.SaveAsSearchablePdf("searchable-output.pdf")

using var input = new OcrInput();
input.LoadImage(labelImagePath);
input.Deskew();    // correct rotation from handheld scanner
input.Contrast();  // recover faded label text
input.DeNoise();   // remove packaging texture interference

var labelText = new IronTesseract().Read(input).Text;
Console.WriteLine($"Confidence: {new IronTesseract().Read(input).Confidence}%");

Imports IronOcr

Using input As New OcrInput()
    input.LoadImage(labelImagePath)
    input.Deskew()    ' correct rotation from handheld scanner
    input.Contrast()  ' recover faded label text
    input.DeNoise()   ' remove packaging texture interference

    Dim labelText = New IronTesseract().Read(input).Text
    Console.WriteLine($"Confidence: {New IronTesseract().Read(input).Confidence}%")
End Using