Dynamsoft Label Recognizer hace una cosa excepcionalmente bien: la extracción de la zona de lectura mecánica (MRZ) de los pasaportes, el escaneo del número de identificación del vehículo (VIN) de los vehículos y la lectura de etiquetas estructuradas de los embalajes industriales, y se niega a hacer cualquier otra cosa. Esa especialización tan limitada se convierte en un problema presupuestario en el momento en que su aplicación necesita un OCR general para documentos, porque entonces tendrá que licenciar Reconocedor de etiquetas Dynamsoft para MRZ, Dynamsoft Barcode Reader para códigos QR, Dynamsoft Document Normalizer para la detección de bordes, y aún así tendrá que buscar una cuarta biblioteca para gestionar documentos de página completa. IronOCR cubre todas esas capacidades en un solo paquete NuGet en $999 perpetuo.

Comprender el reconocedor de etiquetas de Dynamsoft

Dynamsoft Corporation, con sede en Vancouver, Canadá, desarrolló su producto Label Recognizer en torno a una propuesta específica: el reconocimiento fiable de texto estructurado legible por máquina en formatos restringidos. El paquete NuGet del producto es Dynamsoft.DotNet.LabelRecognizer, y su licencia comercial opera exclusivamente en suscripciones anuales — no existe opción perpetua. Contacte con Dynamsoft para precios actuales.

El modelo de reconocimiento de la biblioteca se basa en plantillas. Configuras tareas de reconocimiento a través de una API de configuración JSON (AppendSettingsFromString) y luego llamas a RecognizeFile o RecognizeByFile contra archivos de imagen. Los resultados se presentan como colecciones de líneas que contienen cadenas de texto sin formato. Analizar esas cadenas para convertirlas en datos estructurados significativos (desplazamientos de campo, conversiones de fecha, validación de dígitos de control) es enteramente responsabilidad suya.

Características arquitectónicas clave de Dynamsoft Label Recognizer:

• Motor de reconocimiento basado en plantillas: los patrones MRZ, VIN y de etiquetas requieren configuración de plantilla JSON antes del reconocimiento.
• Salida de texto bruto solamente: RecognizeFile devuelve objetos LineResult con cadenas de texto; sin análisis sintáctico de campos estructurados
• Entrada solo de imágenes: No hay soporte nativo para PDF; Los archivos PDF requieren una conversión externa a imágenes antes de su procesamiento.
• Licencia de suscripción anual: Niveles por dispositivo y por servidor disponibles; contacte con Dynamsoft para precios actuales; no one-time purchase
• Producto independiente para cada función: la lectura de códigos de barras, la normalización de documentos y la optimización de la cámara requieren cada una un producto con licencia independiente.
• Cobertura lingüística limitada: Centrada en formatos MRZ con caracteres latinos; carece de un amplio soporte de documentos multilingües

La API de configuración de tiempo de ejecución JSON

Cada flujo de trabajo de Reconocedor de etiquetas Dynamsoft comienza con un paso de configuración de plantilla. El reconocimiento MRZ, por ejemplo, requiere cargar un documento JSON que declare los parámetros de reconocimiento, los modelos de caracteres y las referencias de región antes de que se pueda realizar cualquier procesamiento de imagen:

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();
}

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

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

La salida de RecognizeFile es texto MRZ bruto como P<GBRSMITH<<JOHN<<<<<<<<<<<<<<<<<<<<<<<<<<<. Para obtener Surname = "SMITH", GivenNames = "JOHN", DocumentNumber, DateOfBirth, y ExpiryDate como propiedades tipadas, implementas un analizador TD1/TD2/TD3 por ti mismo. La documentación de Dynamsoft y los archivos fuente en este repositorio estiman que ese analizador tiene aproximadamente 150 líneas de código de análisis — manejando desfases de caracteres, << separadores de nombres, desambiguación de año de dos dígitos, y validación de dígitos de control — ninguno de los cuales Dynamsoft provee.

Comprender IronOCR

IronOCR es una biblioteca OCR comercial .NET, basada en un motor Tesseract 5 optimizado con una capa de API administrada que se encarga del preprocesamiento, los formatos de entrada, la salida estructurada y el análisis especializado de documentos. La instalación es un solo comando NuGet: dotnet add package IronOcr. Sin gestión de binarios nativos, sin configuración de carpetas tessdata, sin archivos de configuración de plantillas.

Características clave:

• Uso general y especializado: Administra OCR de documentos de página completa, PDF de varias páginas, lotes de imágenes escaneadas y formatos especializados (pasaportes, códigos de barras, matrículas) del mismo paquete.
• Proceso de preprocesamiento automático: corrección de inclinación, reducción de ruido, ajuste de contraste, binarización y mejora de la resolución se ejecutan sin configuración manual en entradas de baja calidad.
• Compatibilidad nativa con PDF: Lea directamente archivos PDF escaneados y digitales, incluidos los protegidos con contraseña, sin necesidad de conversiones externas.
• Jerarquía de salida estructurada: Los resultados muestran páginas, párrafos, líneas, palabras y cuadros delimitadores de caracteres con puntuaciones de confianza.
• Lectura de códigos de barras incorporada: Activa ocr.Configuration.ReadBarCodes = true y los códigos de barras se extraen junto con el texto en la misma pasada
• Más de 125 paquetes de idiomas: Cada idioma se instala como un paquete NuGet independiente; no es necesario gestionar la carpeta tessdata
• Licencias perpetuas: $999 Lite, $1,499 Plus, $2,399 Professional — compra única, todas las plataformas, todas las características incluidas
• Implementación multiplataforma: Windows, Linux, macOS, Docker, AWS y Azure funcionan con el mismo paquete sin necesidad de configuración específica para cada plataforma.

Comparación de características

Comparación detallada de características

Ámbito de especialización frente a ámbito generalista

La decisión arquitectónica más importante que tomó Dynamsoft fue crear una solución especializada, no generalista. Esta decisión tiene consecuencias directas para cualquier aplicación que comience con MRZ o lectura de etiquetas, pero que eventualmente necesite más funcionalidades.

Enfoque de Dynamsoft

Dynamsoft Label Recognizer gestiona exactamente lo que describen sus plantillas JSON y nada más. Una aplicación de procesamiento de pasaportes basada en Dynamsoft necesita tres productos antes de poder gestionar un flujo de trabajo de documentos real:

// 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: Extracción de 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();
    }
}

// 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: Extracción de 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();
    }
}

El código anterior todavía no admite la entrada de archivos PDF. Si el escaneo del pasaporte llega en formato PDF en lugar de JPEG, deberá agregar una biblioteca de renderizado de PDF antes de que se ejecute todo esto. La integración total para un flujo de trabajo de pasaporte real: cuatro productos, cuatro claves de licencia, cuatro superficies de mantenimiento.

Enfoque de IronOCR

IronOCR gestiona el mismo flujo de trabajo de pasaportes (análisis MRZ, OCR de página completa, códigos de barras y entrada de PDF) desde un único paquete:

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
        };
    }
}

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

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

Un paquete, una clave de licencia, una API. La documentación de IronOCR, tanto para la guía de lectura de pasaportes como para la función de lectura de códigos de barras , abarca ambas dentro del mismo contexto de producto, ya que se trata del mismo producto.

Costo y complejidad de múltiples productos

La construcción de un escáner de inventario de almacén demuestra la divergencia del modelo de costos de la manera más clara. El sistema debe leer las etiquetas de los productos (texto), escanear códigos de barras (QR/EAN) y procesar los archivos PDF de envío adjuntos. En el caso de Dynamsoft, se trata de tres productos con licencia independiente y patrones de inicialización separados.

Enfoque de Dynamsoft

// 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();
    }
}

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

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

Los archivos PDF de envío aún requieren un cuarto producto: Dynamsoft no cuenta con una función OCR nativa para PDF. Licencia anual para tres productos Dynamsoft en el nivel por servidor: $5,997+/año. Si se añade una biblioteca de PDF, el coste asciende a más de 6.300 dólares al año antes incluso de escribir una sola línea de lógica de negocio.

Enfoque de IronOCR

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;
    }
}

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

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

IronOCR cubre tanto la documentación OCR basada en regiones como la guía de entrada de PDF sin necesidad de productos adicionales.

Modelo de despliegue

Ambas bibliotecas funcionan de forma local, sin transmisión de datos de documentos a través de la nube. Las principales diferencias en el despliegue radican en los patrones de inicialización, la gestión de archivos de configuración y el contenido que cada biblioteca incluye en su artefacto de despliegue.

Enfoque de Dynamsoft

Dynamsoft requiere llamadas de inicialización estática en la clase SDK antes de crear cualquier instancia. Cada producto tiene su propio patrón de inicialización, y la clave de licencia activa únicamente ese producto específico. Los archivos de configuración de plantillas — los documentos JSON de configuración para MRZ, VIN, o patrones de etiquetas personalizados — deben estar presentes y correctamente referenciados en tiempo de ejecución. Un despliegue que incluye Label Recognizer y Barcode Reader gestiona dos flujos de activación, dos conjuntos de plantillas, y dos cadenas Dispose.

Para implementaciones en almacenes o quioscos, la dependencia del archivo de configuración agrega un artefacto de implementación más allá de los binarios. Las plantillas JSON son archivos separados, no compilados en el paquete. Configura mal la ruta de la plantilla en un nuevo servidor y el reconocimiento devuelve silenciosamente resultados vacíos o arroja un error en tiempo de ejecución durante la llamada AppendSettingsFromString.

Enfoque de IronOCR

IronOCR se implementa como un único paquete NuGet . La activación de la licencia es una asignación de cadena de una sola línea:

// 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");

' 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")

No hay archivos de plantilla. Sin gestión binaria nativa. No hay carpeta tessdata. La guía de despliegue en Docker requiere solo libgdiplus en Linux— una línea apt-get install en el Dockerfile.

FROM mcr.microsoft.com/dotnet/aspnet:8.0
RUN apt-get update && apt-get install -y libgdiplus
COPY --from=build /app/publish /app
WORKDIR /app
ENTRYPOINT ["dotnet", "YourApp.dll"]

FROM mcr.microsoft.com/dotnet/aspnet:8.0
RUN apt-get update && apt-get install -y libgdiplus
COPY --from=build /app/publish /app
WORKDIR /app
ENTRYPOINT ["dotnet", "YourApp.dll"]

El mismo paquete es compatible con Linux , AWS Lambda y Azure App Service sin necesidad de configuración específica para cada plataforma. Para los equipos que utilizan pipelines de CI/CD, no hay archivos de plantilla que controlar mediante control de versiones o que desplegar como artefactos por separado.

Referencia de mapeo de API

Cuando los equipos consideran migrar de Dynamsoft a IronOCR

El ámbito de aplicación se amplía más allá de las zonas de riesgo médico o las etiquetas.

La mayoría de las migraciones ocurren cuando un proyecto comienza de forma limitada —"solo leer pasaportes MRZ"— y luego llegan los requisitos del producto. El cliente quiere archivar los pasaportes escaneados como archivos PDF con capacidad de búsqueda. El equipo de cumplimiento normativo quiere procesar mediante OCR los sellos de visado. La cola de soporte tiene incidencias relacionadas con archivos PDF que Dynamsoft no puede procesar. En ese caso, el equipo mantiene Dynamsoft para MRZ, Plus de una segunda biblioteca OCR para todo lo demás. Dos acuerdos de licencia, dos planes de mantenimiento, dos patrones de API en el mismo código base.IronOCR maneja el requerimiento original de MRZ a través de ReadPassport() y los requerimientos ampliados a través de la misma instancia IronTesseract. Los equipos que pasan de un sistema de dos bibliotecas a un solo paquete suelen reportar una reducción del 30-40% en el código de la capa de integración.

Los costos de suscripción anual no son sostenibles.

Los costos de licenciamiento multiproducto de Dynamsoft se acumulan anualmente — contacte con Dynamsoft para precios actuales. Durante varios años, las tarifas de suscripción anual combinadas para múltiples productos pueden exceder sustancialmente el costo único de $999 de IronOCR. El modelo de licencia perpetua es más importante para productos con un ciclo de vida comercial definido — un sistema de procesamiento de documentos gubernamental que funcionará durante siete años no quiere una dependencia de renovación anual con un proveedor especializado para un componente central.

Se requiere ingresar un archivo PDF.

Dynamsoft Label Recognizer no tiene soporte nativo para PDF. Cada documento en formato PDF requiere un paso de preprocesamiento: convertir cada página en una imagen, procesar la imagen con Dynamsoft, recopilar y volver a ensamblar los resultados. Ese proceso añade una dependencia de renderizado de PDF, un bucle de iteración de página y un problema de mapeo de coordenadas si es necesario correlacionar los resultados del reconocimiento con la geometría original del PDF.IronOCR lee PDFs de forma nativa — ocr.Read("passport-scans.pdf") procesa cada página, y result.Pages te da acceso por página a texto, palabras, y puntajes de confianza. Para los equipos en los que el 20 % o más de los datos de entrada llegan en formato PDF, la solución alternativa de Dynamsoft supone una carga de mantenimiento considerable cada vez que se actualiza la biblioteca de representación de PDF.

El impuesto a la integración de múltiples productos es demasiado alto.

Cada producto adicional de Dynamsoft es una llamada de inicialización estática separada, una cadena Dispose separada, y un archivo de configuración JSON separado a gestionar. Los equipos que han integrado tres productos de Dynamsoft informan que la complejidad de la integración es el principal coste de mantenimiento, no la calidad del reconocimiento. La rotación de claves de licencia, las actualizaciones de la versión del SDK y la implementación de archivos de plantilla deben coordinarse simultáneamente en los tres productos. El modelo de paquete único de IronOCR significa que hay una sola versión para actualizar, una sola clave de licencia para rotar y una sola interfaz API para mantener, independientemente de cuántas funciones de OCR utilice la aplicación.

Se necesitan documentos internacionales.

Dynamsoft Label Recognizer se basa en formatos MRZ de caracteres latinos según el documento 9303 de la OACI. Las aplicaciones que procesan documentos de identidad en idiomas CJK, pasaportes en escritura árabe o etiquetas de envío multilingües alcanzan rápidamente los límites de cobertura lingüística.IronOCR distribuye más de 125 paquetes de idiomas como paquetes NuGet individuales: árabe, chino simplificado, chino tradicional, japonés, coreano y más. Cada uno se instala a través de dotnet add package IronOcr.Languages.Arabic sin cambiar el código de reconocimiento. La guía multilingüe explica cómo lograr el reconocimiento multilingüe simultáneo con tan solo unas líneas de configuración.

Consideraciones comunes sobre la migración

Sustitución del analizador MRZ

El paso de migración más inmediato es reemplazar la combinación Dynamsoft RecognizeFile + analizador TD3 manual con ReadPassport. La ruta de extracción de Dynamsoft devuelve texto bruto como P<GBRSMITH<<JOHN<<<<<<<<<<<<<<<<<<<<<<<<<< y requiere más de 150 líneas de análisis de desfase de caracteres para el formato TD3. El reemplazo de IronOCR:

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

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

El analizador manual se elimina por completo. La detección de formato TD1 (tarjetas de identificación), TD2 (visas), y TD3 (pasaportes) es automática dentro de ReadPassport. El manual de instrucciones para la lectura del pasaporte documenta cada campo devuelto.

Consolidación de la inicialización de múltiples productos

Las aplicaciones multiproducto de Dynamsoft tienen múltiples llamadas estáticas InitLicense al inicio, cada una requiriendo su propia clave. Consolida estos elementos en una única línea de licencia de IronOCR y elimina los bloques de inicialización por producto:

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

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

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

Las llamadas Dynamsoft Dispose existentes en las clases de servicio deben reemplazarse con bloques using estándar en instancias IronTesseract, o una sola instancia reutilizada registrada en el contenedor DI. La guía de configuración de IronTesseract abarca ambos patrones.

Agregar compatibilidad con PDF

La nueva funcionalidad más común que adquieren los equipos durante la migración es la entrada nativa de archivos PDF, algo que Dynamsoft nunca ofreció. Tras eliminar el bucle de conversión de PDF a imagen, la lectura nativa de PDF no requiere cambios en el código más allá de la ruta de entrada:

// 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");

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

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

Para equipos que también necesitan producir archivos PDF archivables y buscables a partir de entradas escaneadas, SaveAsSearchablePdf es una llamada de método única. El documento PDF con instrucciones y función de búsqueda detalla las opciones de salida.

Preprocesamiento para la calidad de las etiquetas industriales

El motor de plantillas de Dynamsoft está optimizado para condiciones de etiquetado controladas. Para imágenes degradadas (etiquetas desgastadas, embalajes de bajo contraste, escaneos industriales distorsionados), el proceso de preprocesamiento de IronOCR soluciona el problema. La guía de corrección de la calidad de imagen cubre cada filtro. Para flujos de trabajo específicos de etiquetas, Deskew y Contrast son los más útiles:

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

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

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

Funcionalidades adicionales de IronOCR

Funcionalidades no cubiertas en las secciones anteriores que los equipos utilizan con frecuencia después de la migración:

• Reconocimiento de escritura a mano : procesa notas y anotaciones manuscritas junto con texto impreso, una capacidad que Dynamsoft no ofrece.
• Procesamiento de documentos escaneados : PDF escaneados de varias páginas con preprocesamiento automático por página.
• Extracción de tablas : Detecta y extrae datos tabulares de facturas, manifiestos y hojas de datos.
• Exportación hOCR : Exporta los resultados del reconocimiento como HTML con coordenadas del cuadro delimitador para el análisis de diseño posterior.
• OCR asíncrono : reconocimiento sin bloqueo para ASP.NET y aplicaciones de servidor de alto rendimiento.
• Seguimiento del progreso : Supervise trabajos por lotes de varias páginas con devoluciones de llamada de progreso.
• Índice de más de 125 idiomas : Lista completa de paquetes NuGet de idiomas compatibles, incluidos los alfabetos no latinos.
• MICR/lectura de cheques : reconocimiento de caracteres de tinta magnética para el procesamiento de documentos financieros: otro caso de uso especializado gestionado en un solo paquete.
• Puntuaciones de confianza por palabra : Señales de calidad detalladas para los procesos automatizados de revisión de documentos.

Compatibilidad con .NET y preparación para el futuro

IronOCR está diseñado para .NET 8 y .NET 9 como entornos de ejecución compatibles de primera clase, con compatibilidad total con versiones anteriores hasta .NET Framework 4.6.2 y .NET Core 3.1. La biblioteca se distribuye como un único paquete NuGet que resuelve automáticamente el binario de plataforma correcto para Windowsx64, Windowsx86, Linuxx64, macOSx64 y macOSARM a través del gráfico de identificadores de tiempo de ejecución de NuGet, sin referencias de paquetes condicionales ni archivos de proyecto específicos de la plataforma. Reconocedor de etiquetas Dynamsoft también es compatible con los entornos de ejecución .NET modernos, pero su modelo multiproducto implica que la compatibilidad de cada producto con .NET debe verificarse y actualizarse de forma independiente. El ritmo de desarrollo activo de IronOCR mantiene las actualizaciones de los paquetes NuGet alineadas con cada ciclo de lanzamiento de .NET , y el modelo de paquete único significa que la compatibilidad con .NET 10, prevista para finales de 2026, se aplicará de manera uniforme a todas las características sin necesidad de un seguimiento por producto.

Conclusión

Dynamsoft Label Recognizer es un especialista con gran capacidad técnica. Para un quiosco que procesa únicamente códigos MRZ de pasaportes, o una estación de línea de montaje que lee solo códigos VIN, su motor de reconocimiento basado en plantillas realiza la tarea específica de forma fiable. El problema es que las aplicaciones reales rara vez se limitan a un ámbito específico. Es necesario que las páginas de datos de los pasaportes se procesen mediante OCR (reconocimiento óptico de caracteres). Las etiquetas de envío llegan en formato PDF. Los sistemas de inventario necesitan códigos de barras y texto en la misma pasada. Cada ampliación del alcance conlleva la necesidad de adquirir otro producto de Dynamsoft, adquirir otra licencia anual y mantener otra interfaz API.

El modelo de costes lo deja claro. Los totales multianuales para MRZ más la lectura de códigos de barras en un equipo de desarrollo que utiliza el modelo de suscripción anual de Dynamsoft se acumulan significativamente.IronOCR cubre ambas capacidades — además de PDF nativo, salida de PDF buscable, OCR de documento completo, 125+ idiomas, y preprocesamiento — en $999 único. La migración en sí es en gran medida mecánica: reemplaza RecognizeFile con ocr.Read, elimina el analizador TD3 MRZ manual, habilita ReadBarCodes = true, y elimina el bucle de renderizado de PDF externo.

La diferencia arquitectónica no radica solo en el costo. El diseño de Dynamsoft obliga a los equipos a pensar en términos de productos en lugar de capacidades, a preguntarse "¿qué producto de Dynamsoft maneja esto?" antes de escribir cualquier código. El diseño de IronOCR invierte ese principio: una instancia, una configuración, un objeto de resultado, independientemente del contenido del documento. Esa diferencia se acentúa a lo largo de la vida de un proyecto a medida que aumentan los requisitos.

Para los equipos que desarrollan aplicaciones desde cero y que necesitan cualquier combinación de reconocimiento de zonas de lectura mecánica (MRZ), lectura de códigos de barras, OCR general de documentos o procesamiento de PDF, el modelo todo en uno de IronOCR elimina desde el principio el problema de la coordinación de múltiples productos. Para los equipos que actualmente utilizan varios productos de Dynamsoft junto con una biblioteca OCR independiente, la ruta de migración consolida esa interfaz en una única dependencia. El centro de documentación de IronOCR abarca todas las funciones aquí comentadas, con ejemplos de código funcionales y guías de implementación.