Comment lire des tableaux dans des documents avec C#35;

Comment extraire des données de tableaux simples ?

Définir la propriété ReadDataTables sur true active la détection des tables à l'aide de Tesseract. Cette approche fonctionne bien pour les tableaux de base dont les limites des cellules sont claires et qui ne comportent pas de cellules fusionnées. J'ai créé un tableau PDF simple pour tester cette fonctionnalité, que vous pouvez télécharger ici : ' simple-table.pdf '. Cette méthode permet de détecter les tableaux simples sans cellules fusionnées. Pour les tableaux plus complexes, reportez-vous à la méthode décrite ci-dessous.

La méthode de détection des tableaux standard est particulièrement efficace pour :

• Exportations de feuilles de calcul
• Tableaux de données de base avec une structure ligne/colonne cohérente
• Rapports contenant des données tabulaires
• Listes d'inventaire simples

Si vous travaillez avec l'extraction de texte OCR de PDF en général, cette méthode s'intègre parfaitement aux capacités plus larges de traitement de documents d'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();
}

Comment lire des tableaux de factures complexes?

<TODO : Ajouter une image ici -->

Les factures figurent parmi les tableaux complexes les plus courants en entreprise. Les factures sont des tableaux complexes comportant des lignes et des colonnes de données, avec souvent des cellules fusionnées, des largeurs de colonnes variables et des structures imbriquées. Avec IronOcr, nous utilisons la méthode ReadDocumentAdvanced pour les traiter efficacement. Le processus consiste à numériser le document, à identifier la structure du tableau et à extraire les données. Dans cet exemple, nous utilisons le fichier 'invoiceTable.pdf' pour montrer comment IronOcr récupère toutes les informations de la facture.

La méthode ReadDocumentAdvanced nécessite l'installation du paquet IronOcr.Extensions.AdvancedScan en plus du paquet IronOCR de base. Cette extension offre des capacités avancées d'apprentissage automatique spécialement formées pour les mises en page de documents complexes.

[{i:( L'utilisation de l'analyse avancée sur .NET Framework nécessite que le projet s'exécute sur une architecture x64. Pour ce faire, accédez à la configuration du projet et décochez l'option " Préférer 32 bits ". Pour en savoir plus, consultez le guide de dépannage suivant : "Advanced Scan on .NET Framework."
@@--BRACKET-FERMETURE--@@

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

Cette méthode sépare les données textuelles du document en deux catégories : celles délimitées par des bordures et celles qui ne le sont pas. Pour le contenu encadré, la bibliothèque le divise ensuite en sous-sections en fonction de la structure du tableau. La méthode excelle dans le traitement :

• Postes de la facture avec des descriptions variées
• Ventilation des prix sur plusieurs colonnes
• Blocs d'adresses de livraison et de facturation
• Sections relatives aux taxes et au calcul du total
• Informations d'en-tête et de pied de page

Les résultats sont présentés ci-dessous. Étant donné que cette méthode se concentre sur les informations entourées de bordures, toute cellule fusionnée s'étendant sur plusieurs lignes sera traitée comme une seule cellule.

À quoi ressemblent les données extraites?

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

Bonnes pratiques pour l'extraction de tableaux

Lorsque vous travaillez avec l'extraction de tableaux dans IronOcr, tenez compte de ces meilleures pratiques :

1. Qualité du document : Les documents de haute résolution donnent de meilleurs résultats. Pour les documents scannés, assurez-vous d'un minimum de 300 DPI.

2. Prétraitement : Pour les documents de mauvaise qualité ou les tableaux de travers, pensez à utiliser les fonctionnalités de correction d'image d'IronOcr avant le traitement.

3. Performance : Pour les documents volumineux comportant plusieurs tableaux, envisagez d'utiliser le multithreading et la prise en charge asynchrone pour traiter les pages en parallèle.

4. Options de sortie : Après avoir extrait les données d'un tableau, vous pouvez exporter les résultats dans différents formats. Pour en savoir plus sur les options de sortie des données et sur la manière de créer des PDF consultables à partir de vos documents traités.

5. Traitement en flux : Pour les applications web ou les scénarios utilisant des documents en mémoire, envisagez d'utiliser OCR pour les flux PDF afin d'éviter les opérations sur le système de fichiers.

Résumé

IronOcr offre de puissantes capacités d'extraction de tableaux grâce à des méthodes de détection standard basées sur Tesseract et des méthodes d'apprentissage automatique avancées. L'approche standard fonctionne bien pour les tableaux simples, tandis que la méthode ReadDocumentAdvanced excelle pour les documents complexes tels que les factures. Grâce aux méthodes d'aide fournies, vous pouvez organiser et traiter les données extraites en fonction de vos besoins spécifiques.

Découvrez d'autres fonctionnalités d'IronOCR pour améliorer vos flux de traitement de documents et exploiter tout le potentiel de la reconnaissance optique de caractères dans vos applications .NET.