API de factura OCR (Tutorial para desarrolladores)
La API de OCR para facturas automatiza la extracción de datos de facturas utilizando aprendizaje automático, eliminando errores de ingreso manual mientras captura con precisión los detalles del proveedor, números de factura y precios tanto de documentos digitales como escaneados. Este tutorial demuestra cómo construir una solución de OCR para facturas con IronOCR.
Aprovechando el aprendizaje automático y la visión por computadora, la tecnología de OCR para facturas transforma los datos de facturas en formatos listos para el procesamiento automatizado. Aprenderás cómo abordar desafíos comunes como retrasos, costos y errores en la entrada manual de datos, mientras extraes con precisión información del proveedor, números de factura y precios de cualquier formato de factura.
Este artículo utiliza IronOCR, una API líder de OCR para facturas para desarrolladores .NET.
Cómo Crear una API de OCR para Facturas
- Descarga e instala la API de OCR para facturas
- Crea un nuevo proyecto C# en Visual Studio o abre uno existente.
- Carga un archivo de imagen existente usando el método
OcrInput - Extrae el texto de la imagen usando el método
Ocr.Read. - Imprime el texto extraído en la consola usando
Console.WriteLine
¿Qué es IronOCR?
IronOCR, desarrollado por Iron Software, proporciona herramientas 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 APIs se integran perfectamente con varios lenguajes y plataformas, reduciendo errores de entrada manual y mejorando la eficiencia. Los datos extraídos fluyen directamente a los sistemas existentes para análisis y toma de decisiones. Funciones como preprocesamiento de imágenes, reconocimiento de códigos de barras y análisis flexible de archivos aumentan su versatilidad. IronOCR permite a los desarrolladores incorporar reconocimiento de texto robusto en sus aplicaciones.
La biblioteca soporta 125 idiomas internacionales mediante paquetes de idiomas especializados, lo que la hace ideal para el procesamiento global de facturas. Las funciones avanzadas incluyen visión por computadora para encontrar texto automáticamente, especialmente útil para facturas con diseños variables. Además, IronOCR ofrece capacidades de procesamiento multihilo para manejar eficientemente el procesamiento de facturas en grandes volúmenes.
¿Por Qué Debería Usar IronOCR para el Procesamiento de Facturas?
IronOCR ofrece ventajas convincentes para aplicaciones de procesamiento de facturas. En primer lugar, proporciona una precisión excepcional gracias a su motor Tesseract 5 optimizado, específicamente mejorado para aplicaciones .NET. La biblioteca maneja varios formatos de factura, desde documentos escaneados hasta archivos PDF e incluso escaneos de baja calidad.
Los filtros de optimización de imagen integrados mejoran automáticamente la calidad de la imagen antes del procesamiento, resultando en una extracción de texto más precisa. Para facturas con requisitos específicos, IronOCR soporta entrenamiento de idiomas personalizado, permitiendo la optimización para fuentes o formatos únicos que se encuentran comúnmente en tus tipos de factura.
¿Qué Hace Diferente a IronOCR de Otras Bibliotecas OCR?
IronOCR se distingue por su capacidad de OCR en una sola línea mientras mantiene características de nivel empresarial. A diferencia de las implementaciones crudas de Tesseract, IronOCR proporciona una API .NET gestionada que maneja operaciones complejas sin problemas. La biblioteca ofrece métodos especializados de lectura de documentos para varios tipos de documentos, incluyendo soporte dedicado para leer tablas en documentos, esencial para los ítems de línea de las facturas.
El Asistente de Filtros determina automáticamente la mejor configuración de preprocesamiento para tus imágenes de factura específicas, eliminando las conjeturas en la optimización. IronOCR también proporciona capacidades de depuración completas, permitiendo a los desarrolladores visualizar lo que ve el motor OCR y solucionar eficazmente problemas de extracción.
¿Qué requisitos previos necesito?
Antes de trabajar con IronOCR, asegúrate de tener estos requisitos previos:
- Un entorno de desarrollo adecuado con un IDE como Visual Studio instalado
- Comprensión básica de programación en C# para comprender y modificar ejemplos de código de manera efectiva
- Biblioteca IronOCR instalada en tu proyecto a través de NuGet Package Manager o línea de comandos
Cumplir con estos requisitos previos te prepara para comenzar a trabajar con IronOCR con éxito.
IronOCR proporciona 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.
¿Qué versión de Visual Studio debo usar?
IronOCR es compatible con las versiones de Visual Studio desde 2017 hasta las más recientes. Para una compatibilidad óptima y acceso a las funciones más nuevas 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 tu entorno de desarrollo.
Para desarrollo multiplataforma, Visual Studio Code con la extensión de C# funciona bien. Los desarrolladores móviles pueden aprovechar la guía de IronOCR para implementaciones en Android y iOS, lo que lo hace adecuado para .NET MAUI applications.
¿Qué nivel de conocimiento de C# necesito?
Un conocimiento intermedio de C# es suficiente para una implementación básica de OCR de facturas. Debes sentirte cómodo con:
- Conceptos de programación orientada a objetos
- Trabajo con streams y entrada/salida de archivos
- Patrones básicos de async/await
- Expresiones regulares para coincidencia de patrones
- Manejo de excepciones para una gestión robusta de errores
El diseño intuitivo de la API de IronOCR significa que no se requiere un conocimiento profundo en procesamiento de imágenes o aprendizaje automático. La biblioteca maneja internamente las operaciones complejas, permitiéndote centrarte en la lógica de negocio. Los principiantes pueden comenzar con ejemplos simples de OCR.
¿Cómo creo un nuevo proyecto de Visual Studio?
Para comenzar con IronOCR, primero crea un nuevo proyecto de Visual Studio.
Abre Visual Studio, ve a Archivos, pasa el cursor sobre Nuevo y haz clic en Proyecto.
Nuevo Proyecto
En la nueva ventana, selecciona Aplicación de Consola y haz clic en Siguiente.
Aplicación de Consola
Aparece una nueva ventana. Ingresa el nombre y la ubicación de tu proyecto, luego haz clic en Siguiente.
Configuración del Proyecto
Finalmente, selecciona el marco de destino y haz clic en Crear.
Marco de Destino
Tu nuevo proyecto de Visual Studio está listo. Vamos a instalar IronOCR.
¿Qué tipo de proyecto funciona mejor para aplicaciones OCR?
Aunque este tutorial utiliza una Aplicación de Consola por simplicidad, IronOCR admite varios tipos de proyectos:
- Aplicaciones de Consola: Ideales para procesamiento por lotes o herramientas de línea de comandos
- Aplicaciones Web: Perfectas para construir APIs o servicios web
- Windows Forms/WPF: Adecuadas para aplicaciones de escritorio con interfaz gráfica
- .NET MAUI Apps: Para soluciones multiplataforma
Para procesamiento de alto volumen, considera implementar IronOCR en un Servicio de Windows o una arquitectura de microservicios. Las capacidades de seguimiento de progreso de la biblioteca facilitan el monitoreo de operaciones de larga duración.
¿Qué versión de .NET Framework debo utilizar?
IronOCR ofrece una amplia compatibilidad entre versiones de .NET. Para proyectos nuevos, apunte a .NET 6.0 o superior para obtener el mejor rendimiento y las funciones más recientes. La biblioteca mantiene una excelente compatibilidad hacia atrás:
- .NET Framework 4.6.2+: Para aplicaciones empresariales heredadas
- .NET Core 3.1: Soporte a largo plazo para implementaciones estables
- .NET 5.0+: Framework moderno con mejoras de rendimiento
- .NET Standard 2.0: Máxima compatibilidad entre plataformas
Al implementar en contenedores Docker, .NET 6.0 o posterior proporciona imágenes más pequeñas y mejor rendimiento. Para Azure Functions, se admiten tanto .NET 6.0 como .NET Framework.
¿Cómo instalo IronOCR?
Existen dos métodos sencillos para descargar e instalar IronOCR:
- Usando el Administrador de paquetes NuGet de Visual Studio
- Usando la línea de comandos de Visual Studio
¿Cuándo debo usar el Administrador de paquetes NuGet vs la línea de comandos?
Elija entre la interfaz gráfica del Administrador de paquetes NuGet y la línea de comandos según su flujo de trabajo:
La interfaz gráfica del Administrador de paquetes NuGet es ideal cuando:
- Es nuevo en los paquetes NuGet
- Desea explorar paquetes de idiomas de IronOCR
- Prefiere confirmación visual
- Administra varios paquetes
La línea de comandos (Consola del Administrador de paquetes) es ideal cuando:
- Se siente cómodo con interfaces de comandos
- Sigue implementaciones automatizadas por scripts
- Necesita versiones específicas rápidamente
- Utiliza opciones avanzadas de instalación
Ambos métodos logran resultados idénticos: elija según su comodidad y necesidades.
¿Qué paquetes de idiomas adicionales podría necesitar?
IronOCR admite 125 idiomas internacionales mediante paquetes especializados. Para el procesamiento de facturas, considere:
- Paquetes específicos de negocios: Paquete de idioma financiero para documentos financieros
- Idiomas regionales: Según el origen de las facturas (español, francés, alemán)
- Soporte multilingüe: Para facturas con varios idiomas
- Idiomas personalizados: Para fuentes especializadas o datos de entrenamiento personalizados
Los paquetes de idiomas se instalan junto con el paquete principal de IronOCR y mejoran significativamente la precisión para textos que no están en inglés.
Uso del Administrador de paquetes NuGet de Visual Studio
Incluya IronOCR en su proyecto C# usando 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
Busque IronOCR e instale el paquete en su proyecto.
Seleccione el paquete IronOCR en la interfaz del Administrador de paquetes NuGet
Instale paquetes de idiomas adicionales usando el mismo método.
Uso de la línea de comandos de Visual Studio
-
En Visual Studio, vaya a Herramientas > Administrador de paquetes NuGet > Consola del Administrador de paquetes
-
Ingrese este comando en la Consola del Administrador de paquetes:
Consola del Administrador de paquetes
El paquete se descarga e instala en su proyecto actual, listo para usar.
¿Cómo extraigo datos de facturas usando IronOCR?
Extraiga datos de facturas fácilmente con IronOCR utilizando solo unas pocas líneas de código. Esto reemplaza la entrada 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
Vamos a extraer 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 = "~`$#^*_}{]";Imports IronOcr
Imports System
' Initialize a new instance of the IronTesseract class
' This is the main OCR engine that will process our invoice
Dim ocr = New IronTesseract()
' Configure OCR settings for better invoice processing
ocr.Configuration.BlackListCharacters = "~`$#^*_}{]"Imports IronOcr
Imports System
' Initialize a new instance of the IronTesseract class
' This is the main OCR engine that will process our invoice
Dim ocr = New IronTesseract()
' Configure OCR settings for better invoice processing
ocr.Configuration.BlackListCharacters = "~`$#^*_}{]"Este ejemplo llama al método Read de la clase IronTesseract. Las mejoras clave incluyen:
- Preprocesamiento de imágenes: Deskew corrige escaneos inclinados; corrección de calidad de imagen elimina artefactos
- Mejora de resolución: Establecer un DPI de entrada más alto mejora el reconocimiento
- Lista negra de caracteres: Previene interpretaciones erróneas comunes en OCR
- Puntuación de confianza: Evalúa la fiabilidad de la extracción

Analizador de facturas
¿Cómo manejo diferentes formatos de factura?
Los formatos de factura varían entre proveedores, pero IronOCR ofrece soluciones flexibles:
- Basado en plantillas: Defina regiones de recorte fijas para cada diseño de proveedor
- Visión por computadora: Utilice visión por computadora para localizar texto
- Extracción de tablas: Aproveche la lectura de tablas para partidas
- Multi-formato: Procese TIFF multipágina, archivos PDF y códigos de barras
Para diseños complejos, implemente un análisis de diseño de documento que utilice aprendizaje automático para identificar estructuras automáticamente.
¿Cuáles son los patrones comunes de extracción para datos de facturas?
Los datos de facturas siguen patrones reconocibles que se pueden extraer usando expresiones regulares con los resultados de OCR:
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; }
}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; }
}Imports IronOcr
Imports System
Imports System.Text.RegularExpressions
Imports System.Collections.Generic
Public Class InvoiceDataExtractor
Private ReadOnly ocr As IronTesseract
Public Sub New()
ocr = New IronTesseract()
' Configure for optimal invoice reading
ocr.Configuration.ReadBarcodes = True ' Many invoices include barcodes
ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5
End Sub
Public Function ExtractInvoiceData(imagePath As String) As InvoiceData
Dim invoiceData As New InvoiceData()
Using input = New OcrInput(imagePath)
' Apply filters for better accuracy
input.EnhanceResolution(300)
input.Sharpen()
Dim result = ocr.Read(input)
Dim 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 Then
invoiceData.BarcodeValues = New List(Of String)()
For Each barcode In result.Barcodes
invoiceData.BarcodeValues.Add(barcode.Value)
Next
End If
End Using
Return invoiceData
End Function
Private Function ExtractPattern(text As String, pattern As String) As String
Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
Return If(match.Success, match.Value, String.Empty)
End Function
Private Function ExtractDate(text As String, pattern As String) As DateTime?
Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
If match.Success AndAlso match.Groups.Count > 1 Then
Dim dateResult As DateTime
If DateTime.TryParse(match.Groups(1).Value, dateResult) Then
Return dateResult
End If
End If
Return Nothing
End Function
Private Function ExtractAmount(text As String, pattern As String) As Decimal
Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
If match.Success AndAlso match.Groups.Count > 1 Then
Dim amountStr = match.Groups(1).Value.Replace(",", "")
Dim amount As Decimal
If Decimal.TryParse(amountStr, amount) Then
Return amount
End If
End If
Return 0
End Function
Private Function ExtractVendorName(text As String) As String
' Usually the vendor name appears in the first few lines
Dim lines = text.Split(ControlChars.Lf)
If lines.Length > 0 Then
' Simple heuristic: first non-empty line that's not a common header
For Each line In lines
Dim trimmed = line.Trim()
If Not String.IsNullOrEmpty(trimmed) AndAlso
Not trimmed.ToLower().Contains("invoice") AndAlso
trimmed.Length > 3 Then
Return trimmed
End If
Next
End If
Return String.Empty
End Function
Private Function ExtractLineItems(result As OcrResult) As List(Of LineItem)
Dim lineItems As New List(Of LineItem)()
' Use IronOCR's table detection capabilities
If result.Tables IsNot Nothing AndAlso result.Tables.Count > 0 Then
For Each table In result.Tables
' Process each row as a potential line item
For i As Integer = 1 To table.RowCount - 1 ' Skip header row
Dim item As New LineItem With {
.Description = If(table(i, 0)?.Text, ""),
.Quantity = ParseQuantity(table(i, 1)?.Text),
.UnitPrice = ParseAmount(table(i, 2)?.Text),
.Total = ParseAmount(table(i, 3)?.Text)
}
If Not String.IsNullOrEmpty(item.Description) Then
lineItems.Add(item)
End If
Next
Next
End If
Return lineItems
End Function
Private Function ParseQuantity(text As String) As Integer
If String.IsNullOrEmpty(text) Then Return 0
Dim cleaned = Regex.Replace(text, "[^\d]", "")
Dim qty As Integer
Return If(Integer.TryParse(cleaned, qty), qty, 0)
End Function
Private Function ParseAmount(text As String) As Decimal
If String.IsNullOrEmpty(text) Then Return 0
Dim cleaned = Regex.Replace(text, "[^\d.]", "")
Dim amt As Decimal
Return If(Decimal.TryParse(cleaned, amt), amt, 0)
End Function
End Class
' Data classes for structured invoice information
Public Class InvoiceData
Public Property InvoiceNumber As String
Public Property InvoiceDate As DateTime?
Public Property DueDate As DateTime?
Public Property VendorName As String
Public Property Total As Decimal
Public Property Tax As Decimal
Public Property LineItems As List(Of LineItem)
Public Property BarcodeValues As List(Of String)
End Class
Public Class LineItem
Public Property Description As String
Public Property Quantity As Integer
Public Property UnitPrice As Decimal
Public Property Total As Decimal
End ClassImports IronOcr
Imports System
Imports System.Text.RegularExpressions
Imports System.Collections.Generic
Public Class InvoiceDataExtractor
Private ReadOnly ocr As IronTesseract
Public Sub New()
ocr = New IronTesseract()
' Configure for optimal invoice reading
ocr.Configuration.ReadBarcodes = True ' Many invoices include barcodes
ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5
End Sub
Public Function ExtractInvoiceData(imagePath As String) As InvoiceData
Dim invoiceData As New InvoiceData()
Using input = New OcrInput(imagePath)
' Apply filters for better accuracy
input.EnhanceResolution(300)
input.Sharpen()
Dim result = ocr.Read(input)
Dim 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 Then
invoiceData.BarcodeValues = New List(Of String)()
For Each barcode In result.Barcodes
invoiceData.BarcodeValues.Add(barcode.Value)
Next
End If
End Using
Return invoiceData
End Function
Private Function ExtractPattern(text As String, pattern As String) As String
Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
Return If(match.Success, match.Value, String.Empty)
End Function
Private Function ExtractDate(text As String, pattern As String) As DateTime?
Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
If match.Success AndAlso match.Groups.Count > 1 Then
Dim dateResult As DateTime
If DateTime.TryParse(match.Groups(1).Value, dateResult) Then
Return dateResult
End If
End If
Return Nothing
End Function
Private Function ExtractAmount(text As String, pattern As String) As Decimal
Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
If match.Success AndAlso match.Groups.Count > 1 Then
Dim amountStr = match.Groups(1).Value.Replace(",", "")
Dim amount As Decimal
If Decimal.TryParse(amountStr, amount) Then
Return amount
End If
End If
Return 0
End Function
Private Function ExtractVendorName(text As String) As String
' Usually the vendor name appears in the first few lines
Dim lines = text.Split(ControlChars.Lf)
If lines.Length > 0 Then
' Simple heuristic: first non-empty line that's not a common header
For Each line In lines
Dim trimmed = line.Trim()
If Not String.IsNullOrEmpty(trimmed) AndAlso
Not trimmed.ToLower().Contains("invoice") AndAlso
trimmed.Length > 3 Then
Return trimmed
End If
Next
End If
Return String.Empty
End Function
Private Function ExtractLineItems(result As OcrResult) As List(Of LineItem)
Dim lineItems As New List(Of LineItem)()
' Use IronOCR's table detection capabilities
If result.Tables IsNot Nothing AndAlso result.Tables.Count > 0 Then
For Each table In result.Tables
' Process each row as a potential line item
For i As Integer = 1 To table.RowCount - 1 ' Skip header row
Dim item As New LineItem With {
.Description = If(table(i, 0)?.Text, ""),
.Quantity = ParseQuantity(table(i, 1)?.Text),
.UnitPrice = ParseAmount(table(i, 2)?.Text),
.Total = ParseAmount(table(i, 3)?.Text)
}
If Not String.IsNullOrEmpty(item.Description) Then
lineItems.Add(item)
End If
Next
Next
End If
Return lineItems
End Function
Private Function ParseQuantity(text As String) As Integer
If String.IsNullOrEmpty(text) Then Return 0
Dim cleaned = Regex.Replace(text, "[^\d]", "")
Dim qty As Integer
Return If(Integer.TryParse(cleaned, qty), qty, 0)
End Function
Private Function ParseAmount(text As String) As Decimal
If String.IsNullOrEmpty(text) Then Return 0
Dim cleaned = Regex.Replace(text, "[^\d.]", "")
Dim amt As Decimal
Return If(Decimal.TryParse(cleaned, amt), amt, 0)
End Function
End Class
' Data classes for structured invoice information
Public Class InvoiceData
Public Property InvoiceNumber As String
Public Property InvoiceDate As DateTime?
Public Property DueDate As DateTime?
Public Property VendorName As String
Public Property Total As Decimal
Public Property Tax As Decimal
Public Property LineItems As List(Of LineItem)
Public Property BarcodeValues As List(Of String)
End Class
Public Class LineItem
Public Property Description As String
Public Property Quantity As Integer
Public Property UnitPrice As Decimal
Public Property Total As Decimal
End ClassProcesamiento de facturas para extraer datos específicos de facturas
Extraiga datos específicos de la factura como los números de factura del cliente 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);
}
}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 = New IronTesseract()
' Use the `OcrInput` object to load the image file
Using input = 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 = "INV/\d{4}/\d{5}"
' Match the pattern in the extracted text
Dim lineMatch = 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 = lineMatch.Value
Console.WriteLine("Customer Invoice number: " & lineValue)
End If
End UsingImports IronOcr
Imports System
Imports System.Text.RegularExpressions
' Initialize a new instance of the `IronTesseract` class
Dim ocr = New IronTesseract()
' Use the `OcrInput` object to load the image file
Using input = 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 = "INV/\d{4}/\d{5}"
' Match the pattern in the extracted text
Dim lineMatch = 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 = lineMatch.Value
Console.WriteLine("Customer Invoice number: " & lineValue)
End If
End Using
Escaneo de facturas
Para escenarios de extracción complejos, utilice configuraciones OCR especializadas para optimizar según sus tipos de factura. La clase OcrResult proporciona información detallada sobre cada elemento reconocido, incluyendo coordenadas y puntuaciones de confianza para validación.
¿Cuáles son los beneficios clave de la API de OCR para facturas?
La API de OCR para facturas de IronOCR transforma el procesamiento de facturas mediante aprendizaje automático y visión por computadora. Esta tecnología convierte el texto de las facturas en formatos legibles por máquina, simplificando la extracción de datos para análisis, integración y mejora de procesos. Ofrece una automatización robusta para el procesamiento de facturas, mejorando la precisión y optimizando flujos de trabajo como cuentas por pagar.
IronOCR ofrece una precisión excepcional utilizando resultados optimizados de Tesseract sin configuración adicional. Es compatible con TIFF multipágina, archivos PDF y todos los formatos de imagen populares. La lectura de códigos de barras desde imágenes añade otra dimensión de extracción.
Beneficios clave para el procesamiento de facturas:
- Ahorro de tiempo: Reduce horas a segundos
- Precisión: Minimiza errores con puntuación de confianza
- Escalabilidad: Procesa miles con multihilo
- Integración: Exporta a PDFs con capacidad de búsqueda o formatos estructurados
- Reducción de costos: Disminuye los costos operativos
La flexibilidad de implementación de la biblioteca permite la integración en sistemas existentes: locales, en la nube o híbridos. Con soporte para 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 dedicado y actualizaciones regulares. Las guías de solución de problemas y el soporte de ingeniería de la biblioteca aseguran una implementación fluida.
Visita la página principal para obtener más información sobre IronOCR. Para tutoriales adicionales de OCR para facturas, consulta esta guía detallada de OCR para facturas. Para aprender sobre el uso de visión por computadora en campos de facturas, revisa este tutorial de visión por computadora.
Artículos relacionados
