Cómo leer tablas en documentos con C

¿Cómo extraer datos de tablas sencillas?

Establecer la propiedad ReadDataTables en verdadero habilita la detección de tablas usando Tesseract. Este enfoque funciona bien para tablas básicas con límites de celda claros y sin celdas combinadas. Creé un PDF de tabla simple para probar esta función, que puedes descargar aquí: 'simple-table.pdf'. Las tablas simples sin celdas fusionadas pueden ser detectadas utilizando este método. Para tablas más complejas, consulte el método descrito a continuación.

El método estándar de detección de tablas es especialmente eficaz para:

• Exportación de hojas de cálculo
• Tablas de datos básicos con una estructura coherente de filas y columnas
• Informes con datos tabulares
• Listas de inventario sencillas

Si se trabaja con Extracción de texto mediante OCR de PDF en general, este método se integra perfectamente con las capacidades más amplias de procesamiento de documentos de IronOcr.

:path=/static-assets/ocr/content-code-examples/how-to/read-table-in-document-with-tesseract.cs

using IronOcr;
using System;
using System.Data;

// Instantiate OCR engine
var ocr = new IronTesseract();

// Enable table detection
ocr.Configuration.ReadDataTables = true;

using var input = new OcrPdfInput("simple-table.pdf");
var result = ocr.Read(input);

// Retrieve the data
var table = result.Tables[0].DataTable;

// Print out the table data
foreach (DataRow row in table.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write(item + "\t");
    }
    Console.WriteLine();
}

¿Cómo puedo leer tablas de facturación complejas?

Una de las tablas complejas más comunes que se encuentran en entornos empresariales son las facturas. Las facturas son tablas complejas con filas y columnas de datos, a menudo con celdas combinadas, anchos de columna variables y estructuras anidadas. Con IronOCR, utilizamos el método ReadDocumentAdvanced para gestionarlos de manera efectiva. El proceso implica escanear el documento, identificar la estructura de la tabla y extraer los datos. En este ejemplo, utilizamos el archivo 'invoiceTable.pdf' para mostrar cómo IronOCR recupera toda la información de la factura.

El método ReadDocumentAdvanced requiere que el paquete IronOcr.Extensions.AdvancedScan se instale junto con el paquete base IronOCR . Esta extensión proporciona capacidades avanzadas de aprendizaje automático específicamente entrenadas para diseños de documentos complejos.

:path=/static-assets/ocr/content-code-examples/how-to/read-table-in-document-with-ml.cs

using IronOcr;
using System.Linq;

// Instantiate OCR engine
var ocr = new IronTesseract();

using var input = new OcrInput();
input.LoadPdf("invoiceTable.pdf");

// Perform OCR
var result = ocr.ReadDocumentAdvanced(input);

var cellList = result.Tables.First().CellInfos;

Este método separa los datos de texto del documento en dos categorías: una encerrada por bordes y otra sin bordes. Para el contenido bordeado, la biblioteca lo divide aún más en subsecciones basadas en la estructura de la tabla. El método destaca en el manejo:

• Partidas de factura con distintas descripciones
• Desglose de precios en varias columnas
• Bloques de direcciones de envío y facturación
• Secciones de impuestos y cálculo total
• Información de cabecera y pie de página

Los resultados se muestran a continuación. Dado que este método se centra en la información delimitada por bordes, cualquier celda combinada que abarque varias filas se tratará como una sola celda.

¿Qué aspecto tienen los datos extraídos?

using System;
using System.Collections.Generic;
using System.Linq;

// A helper class to process table data by sorting cells based on coordinates
public static class TableProcessor
{
    // Method to organize cells by their coordinates (Y top to bottom, X left to right)
    public static List<CellInfo> OrganizeCellsByCoordinates(List<CellInfo> cells)
    {
        // Sort cells by Y (top to bottom), then by X (left to right)
        var sortedCells = cells
            .OrderBy(cell => cell.CellRect.Y)
            .ThenBy(cell => cell.CellRect.X)
            .ToList();

        return sortedCells;
    }

    // Example method demonstrating how to process multiple tables
    public static void ProcessTables(Tables tables)
    {
        foreach (var table in tables)
        {
            var sortedCells = OrganizeCellsByCoordinates(table.CellInfos);

            Console.WriteLine("Organized Table Cells:");

            // Initialize previous Y coordinate
            int previousY = sortedCells.Any() ? sortedCells.First().CellRect.Y : 0;

            foreach (var cell in sortedCells)
            {
                // Print a new line if the Y-coordinate changes, indicating a new row
                if (Math.Abs(cell.CellRect.Y - previousY) > cell.CellRect.Height * 0.8)
                {
                    Console.WriteLine();  // Start a new row
                    previousY = cell.CellRect.Y;
                }

                // Print the cell text followed by a tab
                Console.Write($"{cell.CellText}\t");
            }

            Console.WriteLine("\n--- End of Table ---");  // End of a table
        }
    }

    // Method to extract a specific row by the given index
    public static List<CellInfo> ExtractRowByIndex(TableInfo table, int rowIndex)
    {
        if (table == null || table.CellInfos == null || !table.CellInfos.Any())
        {
            throw new ArgumentException("Table is empty or invalid.");
        }

        var sortedCells = OrganizeCellsByCoordinates(table.CellInfos);
        List<List<CellInfo>> rows = new List<List<CellInfo>>();

        // Group cells into rows based on Y coordinates
        int previousY = sortedCells.First().CellRect.Y;
        List<CellInfo> currentRow = new List<CellInfo>();

        foreach (var cell in sortedCells)
        {
            if (Math.Abs(cell.CellRect.Y - previousY) > cell.CellRect.Height * 0.8)
            {
                // Store the completed row and start a new one
                rows.Add(new List<CellInfo>(currentRow));
                currentRow.Clear();

                previousY = cell.CellRect.Y;
            }

            currentRow.Add(cell);
        }

        // Add the last row if it wasn't added yet
        if (currentRow.Any())
        {
            rows.Add(currentRow);
        }

        // Retrieve the specified row
        if (rowIndex < 0 || rowIndex >= rows.Count)
        {
            throw new IndexOutOfRangeException($"Row index {rowIndex} is out of range.");
        }

        return rows[rowIndex];
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

// A helper class to process table data by sorting cells based on coordinates
public static class TableProcessor
{
    // Method to organize cells by their coordinates (Y top to bottom, X left to right)
    public static List<CellInfo> OrganizeCellsByCoordinates(List<CellInfo> cells)
    {
        // Sort cells by Y (top to bottom), then by X (left to right)
        var sortedCells = cells
            .OrderBy(cell => cell.CellRect.Y)
            .ThenBy(cell => cell.CellRect.X)
            .ToList();

        return sortedCells;
    }

    // Example method demonstrating how to process multiple tables
    public static void ProcessTables(Tables tables)
    {
        foreach (var table in tables)
        {
            var sortedCells = OrganizeCellsByCoordinates(table.CellInfos);

            Console.WriteLine("Organized Table Cells:");

            // Initialize previous Y coordinate
            int previousY = sortedCells.Any() ? sortedCells.First().CellRect.Y : 0;

            foreach (var cell in sortedCells)
            {
                // Print a new line if the Y-coordinate changes, indicating a new row
                if (Math.Abs(cell.CellRect.Y - previousY) > cell.CellRect.Height * 0.8)
                {
                    Console.WriteLine();  // Start a new row
                    previousY = cell.CellRect.Y;
                }

                // Print the cell text followed by a tab
                Console.Write($"{cell.CellText}\t");
            }

            Console.WriteLine("\n--- End of Table ---");  // End of a table
        }
    }

    // Method to extract a specific row by the given index
    public static List<CellInfo> ExtractRowByIndex(TableInfo table, int rowIndex)
    {
        if (table == null || table.CellInfos == null || !table.CellInfos.Any())
        {
            throw new ArgumentException("Table is empty or invalid.");
        }

        var sortedCells = OrganizeCellsByCoordinates(table.CellInfos);
        List<List<CellInfo>> rows = new List<List<CellInfo>>();

        // Group cells into rows based on Y coordinates
        int previousY = sortedCells.First().CellRect.Y;
        List<CellInfo> currentRow = new List<CellInfo>();

        foreach (var cell in sortedCells)
        {
            if (Math.Abs(cell.CellRect.Y - previousY) > cell.CellRect.Height * 0.8)
            {
                // Store the completed row and start a new one
                rows.Add(new List<CellInfo>(currentRow));
                currentRow.Clear();

                previousY = cell.CellRect.Y;
            }

            currentRow.Add(cell);
        }

        // Add the last row if it wasn't added yet
        if (currentRow.Any())
        {
            rows.Add(currentRow);
        }

        // Retrieve the specified row
        if (rowIndex < 0 || rowIndex >= rows.Count)
        {
            throw new IndexOutOfRangeException($"Row index {rowIndex} is out of range.");
        }

        return rows[rowIndex];
    }
}

Mejores prácticas para la extracción de tablas

Cuando trabaje con la extracción de tablas en IronOCR, tenga en cuenta estas prácticas recomendadas:

1. Calidad del documento: Los documentos de mayor resolución producen mejores resultados. Para los documentos escaneados, asegúrese de que tengan un mínimo de 300 DPI.

2. Preprocesamiento: Para documentos de baja calidad o tablas sesgadas, considere el uso de las funciones de corrección de imágenes de IronOCR antes del procesamiento.

3. Rendimiento: Para documentos grandes con múltiples tablas, considere el uso de multithreading y soporte async para procesar páginas en paralelo.

4. Opciones de salida: Después de extraer los datos de la tabla, puedes exportar los resultados en varios formatos. Obtenga más información sobre opciones de salida de datos y sobre cómo crear PDF con capacidad de búsqueda a partir de los documentos procesados.

5. Stream Processing: Para aplicaciones web o escenarios que trabajan con documentos en memoria, considere el uso de OCR para flujos PDF para evitar las operaciones del sistema de archivos.

Resumen

IronOCR ofrece potentes funciones de extracción de tablas mediante la detección estándar basada en Tesseract y métodos avanzados de aprendizaje automático. El enfoque estándar funciona bien para tablas simples, mientras que el método ReadDocumentAdvanced es excelente para documentos complejos como facturas. Con los métodos de ayuda proporcionados, puede organizar y procesar los datos extraídos para adaptarlos a sus necesidades específicas.

Explore más características de IronOCR para mejorar sus flujos de trabajo de procesamiento de documentos y aprovechar todo el potencial del reconocimiento óptico de caracteres en sus aplicaciones .NET.