La API de OCR para facturas automatiza la extracción de datos de facturas mediante el aprendizaje automático, lo que elimina los errores de introducción manual y captura con precisión los datos de los proveedores, los números de factura y los precios, tanto de documentos digitales como escaneados. Este tutorial muestra cómo crear una solución de OCR para facturas con IronOCR.
Al aprovechar el aprendizaje automático y la visión artificial, la tecnología OCR para facturas transforma los datos de las facturas en formatos listos para su procesamiento automatizado. Aprenderás a abordar retos comunes como los retrasos, los costes y los errores derivados de la introducción manual de datos, al tiempo que extraes con precisión la información del proveedor, los números de factura y los precios de cualquier formato de factura.
Este artículo utiliza IronOCR, una API líder de OCR de facturas para desarrolladores de .NET.
OcrInputOcr.Read .Console.WriteLine``IronOCR, desarrollado por Iron Software, ofrece herramientas de OCR completas para desarrolladores. Utiliza aprendizaje automático y visión por computadora para extraer texto de documentos escaneados, imágenes y PDFs, permitiendo el procesamiento automatizado. Sus API se integran a la perfección con diversos lenguajes y plataformas, lo que reduce los errores de introducción manual de datos y mejora la eficiencia. Los datos extraídos se transfieren directamente a los sistemas existentes para su análisis y la toma de decisiones. Características como el preprocesamiento de imágenes, el reconocimiento de BarCodes y el análisis flexible de archivos aumentan su versatilidad. IronOCR permite a los desarrolladores incorporar un reconocimiento de texto robusto en sus aplicaciones.
La biblioteca admite 125 idiomas internacionales a través de paquetes de idiomas especializados, lo que la hace ideal para el procesamiento global de facturas. Entre las funciones avanzadas se incluye la visión artificial para detectar texto automáticamente, lo que resulta especialmente útil para facturas con diseños variables. Además, IronOCR ofrece capacidades de procesamiento multihilo para gestionar de forma eficiente el procesamiento de grandes volúmenes de facturas.
IronOCR ofrece ventajas convincentes para las aplicaciones de procesamiento de facturas. En primer lugar, ofrece una precisión excepcional gracias a su motor Tesseract 5 optimizado, mejorado específicamente para aplicaciones .NET. La biblioteca admite diversos formatos de factura, desde documentos escaneados hasta archivos PDF, e incluso escaneos de baja calidad.
Los filtros de optimización de imágenes integrados mejoran automáticamente la calidad de la imagen antes del procesamiento, lo que da como resultado una extracción de texto más precisa. Para facturas con requisitos específicos, IronOCR admite el entrenamiento de idiomas personalizado, lo que permite la optimización para fuentes o formatos únicos que suelen encontrarse en sus tipos de factura.
IronOCR se distingue por su sencilla capacidad de OCR en una sola línea, al tiempo que mantiene características de nivel Enterprise. A diferencia de las implementaciones básicas de Tesseract, IronOCR proporciona una API .NET gestionada que maneja operaciones complejas a la perfección. La biblioteca ofrece métodos especializados de lectura de documentos para diversos tipos de documentos, incluyendo soporte específico para la lectura de tablas en documentos, algo esencial para las partidas de factura.
El Asistente de filtros determina automáticamente la mejor configuración de preprocesamiento para tus imágenes de facturas específicas, eliminando las conjeturas en la optimización. IronOCR también ofrece amplias capacidades de depuración, lo que permite a los desarrolladores visualizar lo que ve el motor OCR y resolver eficazmente los problemas de extracción.
Antes de trabajar con IronOCR, asegúrese de que se cumplen los siguientes requisitos previos:
Cumplir estos requisitos previos te prepara para empezar a trabajar con IronOCR con éxito.
IronOCR ofrece guías de configuración completas para Windows, Linux y macOS. La biblioteca admite la implementación en la nube con tutoriales específicos para AWS Lambda y Azure Functions.
IronOCR es compatible con las versiones de Visual Studio desde 2017 hasta las últimas versiones. Para una compatibilidad óptima y acceso a las últimas características de C#, se recomienda Visual Studio 2019 o 2022. La biblioteca es totalmente compatible con .NET Framework, .NET Core y .NET 5+, lo que garantiza flexibilidad en su entorno de desarrollo.
Para el desarrollo multiplataforma, Visual Studio Code con la extensión C# funciona bien. Los desarrolladores de aplicaciones móviles pueden aprovechar las directrices de IronOCR para implementaciones en Android e iOS, lo que la hace adecuada para aplicaciones .NET MAUI.
Basta con tener conocimientos intermedios de C# para la implementación básica del OCR de facturas. Debes sentirte cómodo con:
El diseño intuitivo de la API de IronOCR hace que no sea necesario tener un profundo conocimiento en procesamiento de imágenes o aprendizaje automático. La biblioteca gestiona operaciones complejas internamente, lo que le permite centrarse en la lógica de negocio. Los principiantes pueden empezar con ejemplos sencillos de OCR.
Para empezar con IronOCR, primero crea un nuevo proyecto de Visual Studio.
Abre Visual Studio, ve a Archivos, pasa el cursor por Nuevo y haz clic en Proyecto.
Nuevo Proyecto
En la nueva ventana, seleccione "Aplicación de consola" y haga clic en "Siguiente".
Aplicación de Consola
Aparece una nueva ventana. Introduzca el nombre y la ubicación de su proyecto y, a continuación, haga clic en Siguiente.
Configuración del Proyecto
Por último, selecciona el marco de destino y haz clic en Crear.
Marco de Trabajo Objetivo
Tu nuevo proyecto de Visual Studio está listo. Vamos a instalar IronOCR.
Aunque este tutorial utiliza una aplicación de consola para simplificar, IronOCR admite varios tipos de proyectos:
Para el procesamiento de grandes volúmenes, considere la posibilidad de implementar IronOCR en un servicio de Windows o en una arquitectura de microservicios. Las capacidades de seguimiento del progreso de la biblioteca facilitan la supervisión de operaciones de larga duración.
IronOCR ofrece una amplia compatibilidad con todas las versiones de .NET. Para nuevos proyectos, utilice .NET 6.0 o superior para obtener un rendimiento óptimo y las últimas funciones. La biblioteca mantiene una excelente compatibilidad con versiones anteriores:
Al implementar en contenedores Docker, .NET 6.0 o posterior ofrece imágenes de menor tamaño y un mejor rendimiento. En el caso de Azure Functions, se admiten tanto .NET 6.0 como .NET Framework.
Existen dos métodos sencillos para descargar e instalar IronOCR:
Elige entre la interfaz gráfica de usuario de NuGet Package Manager y la línea de comandos en función de tu flujo de trabajo:
La interfaz gráfica de usuario del gestor de paquetes NuGet funciona mejor cuando:
La línea de comandos (Consola del Administrador de paquetes) destaca cuando:
Ambos métodos ofrecen resultados idénticos; elija el que le resulte más cómodo y se adapte a sus necesidades.
IronOCR admite 125 idiomas internacionales a través de paquetes especializados. Para el procesamiento de facturas, tenga en cuenta:
Los paquetes de idiomas se instalan junto con el paquete principal de IronOCR y mejoran significativamente la precisión en textos que no están en inglés.
Incluya IronOCR en su proyecto de C# utilizando el Administrador de paquetes NuGet de Visual Studio.
Vaya a Herramientas > Administrador de paquetes NuGet > Administrar paquetes NuGet para la solución
Administrador de Paquetes NuGet
Busca IronOCR e instala el paquete en tu proyecto.
Selecciona el paquete IronOCR en el Administrador de Paquetes NuGet
Instala paquetes de idiomas adicionales utilizando el mismo método.
En Visual Studio, ve a Herramientas > Administrador de Paquetes NuGet > Consola del Administrador de Paquetes
Introduzca este comando en la consola del gestor de paquetes:
Consola del Administrador de Paquetes
El paquete se descarga e instala en tu proyecto actual, listo para su uso.
Extraiga datos de facturas fácilmente con IronOCR utilizando solo unas pocas líneas de código. Esto sustituye la introducción manual de datos y agiliza su flujo de trabajo.
Aquí hay un ejemplo de factura para la extracción de texto:
La factura de muestra
Extraigamos todos los datos de esta factura:
using IronOcr;
using System;
// Initialize a new instance of the IronTesseract class
// This is the main OCR engine that will process our invoice
var ocr = new IronTesseract();
// Configure OCR settings for better invoice processing
ocr.Configuration.BlackListCharacters = "~`$#^*_}{]___PROTECTED_LINK_48___ method from ___PROTECTED_LINK_49___ class. Key enhancements include:
- **Image preprocessing**: ___PROTECTED_LINK_50___ corrects tilted scans; ___PROTECTED_LINK_51___ removes artifacts
- **Resolution enhancement**: Setting ___PROTECTED_LINK_52___ improves recognition
- **Character blacklisting**: Prevents common OCR misinterpretations
- **Confidence scoring**: Assesses extraction reliability
!___PROTECTED_LINK_53___
**Invoice Parser**
### How Do I Handle Different Invoice Formats?
Invoice formats vary between vendors, but IronOCR provides flexible solutions:
1. **Template-based**: Define ___PROTECTED_LINK_54___
2. **Computer vision**: Use ___PROTECTED_LINK_55___ to locate text
3. **Table extraction**: Leverage ___PROTECTED_LINK_56___ for line items
4. **Multi-format**: Process ___PROTECTED_LINK_57___, ___PROTECTED_LINK_58___, and ___PROTECTED_LINK_59___
For complex layouts, implement the ___PROTECTED_LINK_60___ which uses machine learning to identify structures automatically.
### What Are Common Extraction Patterns for Invoice Data?
Invoice data follows recognizable patterns extractable using regular expressions with OCR results:
```csharp
using IronOcr;
using System;
using System.Text.`RegularExpressions`;
using System.Collections.Generic;
public class `InvoiceDataExtractor`
{
private readonly `IronTesseract` ocr;
public `InvoiceDataExtractor`()
{
ocr = new `IronTesseract`();
// Configure for optimal invoice reading
`ocr.Configuration`.`ReadBarcodes` = true; // Many invoices include barcodes
`ocr.Configuration`.`TesseractVersion` = `TesseractVersion`.Tesseract5;
}
public `InvoiceData` `ExtractInvoiceData`(string imagePath)
{
var invoiceData = new `InvoiceData`();
using (var input = new `OcrInput`(imagePath))
{
// Apply filters for better accuracy
input.`EnhanceResolution`(300);
`input.Sharpen`();
var result = `ocr.Read`(input);
var text = `result.Text`;
// Extract invoice number
invoiceData.`InvoiceNumber` = `ExtractPattern`(text,
@"INV[/-]?\d{4}[/-]?\d{5}|Invoice\s*#?\s*:?\s*(\d+)");
// Extract dates
invoiceData.`InvoiceDate` = `ExtractDate`(text,
@"Invoice\s*Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})");
invoiceData.`DueDate` = `ExtractDate`(text,
@"Due\s*Date\s*:?\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})");
// Extract amounts
`invoiceData.Total` = `ExtractAmount`(text,
@"Total\s*:?\s*\$?\s*([\d,]+\.?\d*)");
`invoiceData.Tax` = `ExtractAmount`(text,
@"Tax\s*:?\s*\$?\s*([\d,]+\.?\d*)");
// Extract vendor information
invoiceData.`VendorName` = `ExtractVendorName`(text);
// Extract line items using table detection
invoiceData.`LineItems` = `ExtractLineItems`(result);
// Extract any barcodes found
if (`result.Barcodes`.Length > 0)
{
invoiceData.`BarcodeValues` = new List<string>();
foreach (var barcode in `result.Barcodes`)
{
invoiceData.`BarcodeValues`.Add(`barcode.Value`);
}
}
}
return invoiceData;
}
private string `ExtractPattern`(string text, string pattern)
{
var match = Regex.Match(text, pattern, `RegexOptions`.`IgnoreCase`);
return `match.Success` ? `match.Value` : `string.Empty`;
}
private `DateTime`? `ExtractDate`(string text, string pattern)
{
var match = Regex.Match(text, pattern, `RegexOptions`.`IgnoreCase`);
if (`match.Success` && `match.Groups`.Count > 1)
{
if (`DateTime`.`TryParse`(`match.Groups`[1].Value, out `DateTime` date))
return date;
}
return null;
}
private decimal `ExtractAmount`(string text, string pattern)
{
var match = Regex.Match(text, pattern, `RegexOptions`.`IgnoreCase`);
if (`match.Success` && `match.Groups`.Count > 1)
{
var amountStr = `match.Groups`[1].Value.Replace(",", "");
if (decimal.`TryParse`(amountStr, out decimal amount))
return amount;
}
return 0;
}
private string `ExtractVendorName`(string text)
{
// Usually the vendor name appears in the first few lines
var lines = `text.Split`('\n');
if (`lines.Length` > 0)
{
// Simple heuristic: first non-empty line that's not a common header
foreach (var line in lines)
{
var trimmed = `line.Trim`();
if (!string.`IsNullOrEmpty`(trimmed) &&
!trimmed.`ToLower`().Contains("invoice") &&
`trimmed.Length` > 3)
{
return trimmed;
}
}
}
return `string.Empty`;
}
private List<`LineItem`> `ExtractLineItems`(`OcrResult` result)
{
var lineItems = new List<`LineItem`>();
// Use IronOCR's table detection capabilities
if (`result.Tables` != null && `result.Tables`.Count > 0)
{
foreach (var table in `result.Tables`)
{
// Process each row as a potential line item
for (int i = 1; i < table.`RowCount`; i++) // Skip header row
{
var item = new `LineItem`
{
Description = table[i, 0]?.Text ?? "",
Quantity = `ParseQuantity`(table[i, 1]?.Text),
`UnitPrice` = `ParseAmount`(table[i, 2]?.Text),
Total = `ParseAmount`(table[i, 3]?.Text)
};
if (!string.`IsNullOrEmpty`(`item.Description`))
`lineItems.Add`(item);
}
}
}
return lineItems;
}
private int `ParseQuantity`(string text)
{
if (string.`IsNullOrEmpty`(text)) return 0;
var cleaned = Regex.Replace(text, @"[^\d]", "");
return int.`TryParse`(cleaned, out int qty) ? qty : 0;
}
private decimal `ParseAmount`(string text)
{
if (string.`IsNullOrEmpty`(text)) return 0;
var cleaned = Regex.Replace(text, @"[^\d.]", "");
return decimal.`TryParse`(cleaned, out decimal amt) ? amt : 0;
}
}
// Data classes for structured invoice information
public class `InvoiceData`
{
public string `InvoiceNumber` { get; set; }
public `DateTime`? `InvoiceDate` { get; set; }
public `DateTime`? `DueDate` { get; set; }
public string `VendorName` { get; set; }
public decimal Total { get; set; }
public decimal Tax { get; set; }
public List<`LineItem`> `LineItems` { get; set; }
public List<string> `BarcodeValues` { get; set; }
}
public class `LineItem`
{
public string Description { get; set; }
public int Quantity { get; set; }
public decimal `UnitPrice` { get; set; }
public decimal Total { get; set; }
}Extraiga datos específicos de facturas, como los números de factura de los clientes, con este código:
using IronOcr;
using System;
using System.Text.`RegularExpressions`;
// Initialize a new instance of the `IronTesseract` class
var ocr = new `IronTesseract`();
// Use the `OcrInput` object to load the image file
using (var input = new `OcrInput`(@"`r2.png`"))
{
// Perform OCR on the image
var result = `ocr.Read`(input);
// Define a regular expression pattern for the invoice number
var linePattern = @"INV\/\d{4}\/\d{5}";
// Match the pattern in the extracted text
var lineMatch = Regex.Match(`result.Text`, linePattern);
// Check if the pattern matches any part of the text
if (`lineMatch.Success`)
{
// If a match is found, print the invoice number
var lineValue = `lineMatch.Value`;
Console.`WriteLine`("Customer Invoice number: " + lineValue);
}
}Imports IronOcr
Imports System
Imports System.Text.RegularExpressions
' Initialize a new instance of the IronTesseract class
Dim ocr As New IronTesseract()
' Use the OcrInput object to load the image file
Using input As New OcrInput("r2.png")
' Perform OCR on the image
Dim result = ocr.Read(input)
' Define a regular expression pattern for the invoice number
Dim linePattern As String = "INV/\d{4}/\d{5}"
' Match the pattern in the extracted text
Dim lineMatch As Match = Regex.Match(result.Text, linePattern)
' Check if the pattern matches any part of the text
If lineMatch.Success Then
' If a match is found, print the invoice number
Dim lineValue As String = lineMatch.Value
Console.WriteLine("Customer Invoice number: " & lineValue)
End If
End Using
Escaneo de Facturas
Para casos de extracción complejos, utilice configuraciones de OCR especializadas para optimizar el proceso según sus tipos de factura. La clase OcrResult proporciona información detallada sobre cada elemento reconocido, incluyendo coordenadas y puntuaciones de confianza para su validación.
La API de OCR para facturas de IronOCR transforma el procesamiento de facturas mediante el aprendizaje automático y la visión artificial. Esta tecnología convierte el texto de las facturas a formatos legibles por máquina, lo que simplifica la extracción de datos para su análisis, integración y mejora de procesos. Ofrece una sólida automatización para el procesamiento de facturas, lo que mejora la precisión y optimiza flujos de trabajo como el de cuentas por pagar.
IronOCR ofrece una precisión excepcional utilizando resultados optimizados de Tesseract sin necesidad de configuración adicional. Soporta TIFF de frame multipágina, archivos PDF y todos los formatos de imagen populares. La lectura de BarCodes a partir de imágenes añade otra dimensión a la extracción.
Ventajas clave para el procesamiento de facturas:
La flexibilidad de implementación de la biblioteca permite su integración en sistemas existentes, ya sean locales, en la nube o híbridos. Con compatibilidad con Docker, Azure y AWS, IronOCR se adapta a tus necesidades.
Los entornos de producción se benefician de las opciones de licencia de IronOCR, que incluyen soporte técnico dedicado y actualizaciones periódicas. Las guías de resolución de problemas y el soporte técnico de la biblioteca garantizan una implementación fluida.
Visita la página de inicio para obtener más información sobre IronOCR. Para obtener más tutoriales sobre OCR de facturas, consulta esta guía detallada sobre OCR de facturas. Para obtener más información sobre el uso de la visión artificial en los campos de las facturas, consulta este tutorial de visión artificial.
IronOCR es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Tesseract OCR en los idiomas que necesita, soportamos más de 125.
