Comment lire les tableaux dans les documents avec C

This article was translated from English: Does it need improvement?
Translated
View the article in English

Parlons de la lecture des tableaux dans les documents. Extraire des données de tableaux à l'aide de Tesseract simple peut s'avérer difficile, car le texte se trouve souvent dans des cellules et est dispersé de manière éparse dans le document. Cependant, notre bibliothèque est équipée d'un modèle d'apprentissage automatique qui a été entraîné et optimisé pour détecter et extraire avec précision les données tabulaires.

Pour les tableaux simples, vous pouvez vous fier à une détection de tableau directe, tandis que pour les structures plus complexes, notre méthode exclusive ReadDocumentAdvanced fournit des résultats robustes, analysant efficacement le tableau et fournissant les données.

Démarrage rapide : Extraire des cellules de tableau complexes en un seul appel

Soyez opérationnel en quelques minutes : cet exemple montre comment un simple appel IronOCR utilisant ReadDocumentAdvanced vous fournit des données détaillées sur les cellules d'un tableau à partir d'un document complexe. Il démontre sa facilité d'utilisation en chargeant un PDF, en appliquant une détection de tableau avancée et en renvoyant directement une liste d'informations sur les cellules.

Nuget IconCommencez dès maintenant à créer des PDF avec NuGet :

  1. Installez IronOCR avec le gestionnaire de packages NuGet

    PM > Install-Package IronOcr

  2. Copiez et exécutez cet extrait de code.

    var cells = new IronTesseract().ReadDocumentAdvanced(new OcrInput().LoadPdf("invoiceTable.pdf")).Tables.First().CellInfos;
  3. Déployez pour tester sur votre environnement de production.

    Commencez à utiliser IronOCR dans votre projet dès aujourd'hui grâce à un essai gratuit.
    arrow pointer

Les étapes suivantes vous guideront pour commencer à lire des tableaux à l'aide d'IronOCR :


Exemple de tableau simple

Définir la propriété ReadDataTables sur true active la détection des tables à l'aide de Tesseract. 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, veuillez vous référer à la méthode décrite ci-dessous.

: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();
}
Imports Microsoft.VisualBasic
Imports IronOcr
Imports System
Imports System.Data

' Instantiate OCR engine
Private ocr = New IronTesseract()

' Enable table detection
ocr.Configuration.ReadDataTables = True

Dim input = New OcrPdfInput("simple-table.pdf")
Dim result = ocr.Read(input)

' Retrieve the data
Dim table = result.Tables(0).DataTable

' Print out the table data
For Each row As DataRow In table.Rows
	For Each item In row.ItemArray
		Console.Write(item & vbTab)
	Next item
	Console.WriteLine()
Next row
$vbLabelText   $csharpLabel

Exemple de lecture de factures

Les factures figurent parmi les tableaux complexes les plus courants en entreprise. Les factures sont elles-mêmes des tableaux complexes comportant des lignes et des colonnes de données. Avec IronOCR, nous utilisons la méthode ReadDocumentAdvanced pour les traiter de manière optimale. Le processus consiste à numériser le document, à identifier la structure du tableau et à extraire les données. Dans cet exemple, nous utiliserons le fichier " invoiceTable.pdf " pour montrer comment IronOCR récupère toutes les informations de la facture.

La méthode ReadDocumentAdvanced nécessite que le package IronOcr.Extensions.AdvancedScan soit installé en plus du package IronOCR de base.

Veuillez noter 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 : " Analyse avancée sur .NET Framework ".

: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;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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. Les résultats sont présentés ci-dessous. Il est important de noter que, puisque cette méthode se concentre sur les informations délimitées par des bordures, toutes les cellules fusionnées s'étendant sur plusieurs lignes seront traitées comme une seule cellule.

Résultat

Lire le tableau dans le document

Classe d'assistance

Dans la version actuelle, les cellules extraites ne sont pas encore correctement organisées. Cependant, chaque cellule contient des informations précieuses telles que les coordonnées X et Y, les dimensions, et bien plus encore. À partir de ces données, nous pouvons créer une classe d'assistance à diverses fins. Voici quelques méthodes d'assistance de base :

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];
    }
}
Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Linq

' A helper class to process table data by sorting cells based on coordinates
Public Module TableProcessor
	' Method to organize cells by their coordinates (Y top to bottom, X left to right)
	Public Function OrganizeCellsByCoordinates(ByVal cells As List(Of CellInfo)) As List(Of CellInfo)
		' Sort cells by Y (top to bottom), then by X (left to right)
		Dim sortedCells = cells.OrderBy(Function(cell) cell.CellRect.Y).ThenBy(Function(cell) cell.CellRect.X).ToList()

		Return sortedCells
	End Function

	' Example method demonstrating how to process multiple tables
	Public Sub ProcessTables(ByVal tables As Tables)
		For Each table In tables
			Dim sortedCells = OrganizeCellsByCoordinates(table.CellInfos)

			Console.WriteLine("Organized Table Cells:")

			' Initialize previous Y coordinate
			Dim previousY As Integer = If(sortedCells.Any(), sortedCells.First().CellRect.Y, 0)

			For Each 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 Then
					Console.WriteLine() ' Start a new row
					previousY = cell.CellRect.Y
				End If

				' Print the cell text followed by a tab
				Console.Write($"{cell.CellText}" & vbTab)
			Next cell

			Console.WriteLine(vbLf & "--- End of Table ---") ' End of a table
		Next table
	End Sub

	' Method to extract a specific row by the given index
	Public Function ExtractRowByIndex(ByVal table As TableInfo, ByVal rowIndex As Integer) As List(Of CellInfo)
		If table Is Nothing OrElse table.CellInfos Is Nothing OrElse Not table.CellInfos.Any() Then
			Throw New ArgumentException("Table is empty or invalid.")
		End If

		Dim sortedCells = OrganizeCellsByCoordinates(table.CellInfos)
		Dim rows As New List(Of List(Of CellInfo))()

		' Group cells into rows based on Y coordinates
		Dim previousY As Integer = sortedCells.First().CellRect.Y
		Dim currentRow As New List(Of CellInfo)()

		For Each cell In sortedCells
			If Math.Abs(cell.CellRect.Y - previousY) > cell.CellRect.Height * 0.8 Then
				' Store the completed row and start a new one
				rows.Add(New List(Of CellInfo)(currentRow))
				currentRow.Clear()

				previousY = cell.CellRect.Y
			End If

			currentRow.Add(cell)
		Next cell

		' Add the last row if it wasn't added yet
		If currentRow.Any() Then
			rows.Add(currentRow)
		End If

		' Retrieve the specified row
		If rowIndex < 0 OrElse rowIndex >= rows.Count Then
			Throw New IndexOutOfRangeException($"Row index {rowIndex} is out of range.")
		End If

		Return rows(rowIndex)
	End Function
End Module
$vbLabelText   $csharpLabel

Questions Fréquemment Posées

Comment puis-je améliorer l'extraction des données des tableaux dans les documents en utilisant C# ?

Vous pouvez améliorer l'extraction des données des tableaux dans les documents en utilisant C# grâce au modèle d'apprentissage machine d'IronOCR, qui est spécifiquement entraîné pour détecter et extraire les données de tableaux complexes avec précision. Cette approche est plus efficace que l'utilisation d'outils OCR standard comme Tesseract.

Quel est le but de la méthode `ReadDocumentAdvanced` dans IronOCR ?

La méthode `ReadDocumentAdvanced` dans IronOCR est conçue pour gérer des tableaux complexes en fournissant des résultats robustes grâce à un traitement efficace et une extraction de données. Elle est particulièrement utile pour traiter des tableaux aux structures complexes.

Comment puis-je commencer avec l'extraction de tableaux en utilisant IronOCR ?

Pour commencer à extraire des tableaux en utilisant IronOCR, téléchargez la bibliothèque C#, préparez votre document, activez la détection des tableaux en réglant la propriété ReadDataTables, et utilisez la méthode ReadDocumentAdvanced pour des tableaux complexes.

Quel package supplémentaire est requis pour l'extraction avancée de tableaux dans IronOCR ?

L'extraction avancée de tableaux dans IronOCR nécessite le package `IronOcr.Extensions.AdvancedScan`, qui est spécifique à Windows, pour gérer efficacement les structures complexes des tableaux.

Comment puis-je organiser les données des tableaux extraits en utilisant IronOCR ?

IronOCR fournit des méthodes d'aide pour organiser les données des tableaux extraits par coordonnées, vous permettant de traiter plusieurs tableaux et d'extraire des lignes spécifiques par index pour une meilleure gestion des données.

Quelles métadonnées sont incluses dans les cellules des tableaux extraits à l'aide d'IronOCR ?

Les cellules de tableau extraites à l'aide d'IronOCR incluent des métadonnées telles que les coordonnées X et Y, les dimensions des cellules et le contenu textuel de chaque cellule, permettant une analyse et une organisation détaillées des données.

Comment puis-je assurer la compatibilité avec .NET Framework lors de l'utilisation d'IronOCR pour l'extraction de tableaux ?

Pour garantir la compatibilité avec .NET Framework, assurez-vous que votre projet fonctionne sur une architecture x64 et décochez l'option 'Préférer 32 bits' dans la configuration du projet lors de l'utilisation d'IronOCR pour l'extraction de tableaux.

Curtis Chau
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite
Revu par
Jeff Fritz
Jeffrey T. Fritz
Responsable principal du programme - Équipe de la communauté .NET
Jeff est également responsable principal du programme pour les équipes .NET et Visual Studio. Il est le producteur exécutif de la série de conférences virtuelles .NET Conf et anime 'Fritz and Friends', une diffusion en direct pour développeurs qui est diffusée deux fois par semaine où il parle de technologie et écrit du code avec les téléspectateurs. Jeff écrit des ateliers, des présentations et prévoit du contenu pour les plus grands événements de développement Microsoft, y compris Microsoft Build, Microsoft Ignite, .NET Conf et le sommet Microsoft MVP
Prêt à commencer?
Nuget Téléchargements 5,167,857 | Version: 2025.11 vient de sortir