Comment extraire les données de tableau d'un fichier PDF en C#

Quand avez-vous besoin d'extraire des tables à partir de documents PDF ?

Les tableaux sont un moyen pratique de structurer et d'afficher vos données, que ce soit pour la gestion d'inventaire, la saisie de données, l'enregistrement de données telles que la pluviométrie, etc. Ainsi, il peut également y avoir de nombreuses raisons de devoir extraire des tableaux et des données tabulaires à partir de documents PDF. Certains des cas d'utilisation les plus courants comprennent :

• Automatisation de la saisie de données : L'extraction de données des tableaux dans les rapports ou factures PDF peut automatiser des processus tels que le remplissage de bases de données ou de feuilles de calcul.
• Analyse de données : Les entreprises reçoivent souvent des rapports structurés au format PDF. L'extraction des tableaux vous permet d'analyser ces données de manière programmée.
• Conversion de documents : L'extraction de données tabulaires dans des formats plus accessibles comme Excel ou CSV permet une manipulation, un stockage et un partage plus faciles.
• Audit et conformité : Pour les dossiers juridiques ou financiers, l'extraction programmée de données tabulaires à partir de documents PDF peut aider à automatiser les audits et garantir la conformité.

Comment fonctionnent les tableaux PDF ?

Le format de fichier PDF n'offre aucune capacité native pour stocker des données dans des formats structurés comme des tableaux. Le tableau utilisé dans l'exemple d'aujourd'hui a été créé en HTML, avant d'être converti au format PDF. Les tableaux sont rendus sous forme de texte et de lignes, donc l'extraction des données tabulaires nécessite souvent une certaine analyse et interprétation du contenu, sauf si vous utilisez un logiciel OCR, tel que IronOCR.

Comment extraire des données tabulaires d'un fichier PDF en C#

Avant d'explorer comment IronPDF peut s'attaquer à cette tâche, examinons d'abord un outil en ligne capable de gérer l'extraction PDF. Pour extraire un tableau d'un document PDF à l'aide d'un outil PDF en ligne, suivez les étapes ci-dessous :

1. Accédez à l'outil d'extraction PDF en ligne gratuit
2. Téléchargez le PDF contenant le tableau
3. Visualisez et téléchargez les résultats

Extraire des données tabulaires à l'aide de IronPDF

IronPDF vous permet d'extraire des données, du texte et des graphiques à partir de PDFs, qui peuvent ensuite être utilisés pour reconstruire des tables de manière programmatique. Pour ce faire, vous devrez d'abord extraire le contenu textuel du tableau PDF, puis utiliser ce texte pour analyser le tableau en lignes et colonnes. Avant de commencer à extraire des tableaux, voyons comment fonctionne la méthode d'IronPDF ExtractAllText() en extrayant les données d'un tableau :

using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("example.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Output the extracted text to the console
        Console.WriteLine(text);
    }
}

using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("example.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Output the extracted text to the console
        Console.WriteLine(text);
    }
}

Imports IronPDF

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the PDF document
		Dim pdf As PdfDocument = PdfDocument.FromFile("example.pdf")

		' Extract all text from the PDF
		Dim text As String = pdf.ExtractAllText()

		' Output the extracted text to the console
		Console.WriteLine(text)
	End Sub
End Class

Dans cet exemple, nous avons chargé le document PDF en utilisant la classe PdfDocument, puis utilisé la méthode ExtractAllText() pour extraire tout le texte du document, avant de finalement afficher le texte sur la console.

Extraction de données tabulaires depuis le texte avec IronPDF

Après avoir extrait le texte du PDF, le tableau apparaîtra comme une série de lignes et de colonnes en texte brut. Vous pouvez diviser ce texte en fonction des sauts de ligne (\n) et ensuite diviser encore plus les lignes en colonnes en fonction d'un espacement constant ou de délimiteurs tels que des virgules ou des tabulations. Voici un exemple de base sur la façon d'analyser le tableau à partir du texte :

using IronPDF;
using System;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("table.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Split the text into lines (rows)
        string[] lines = text.Split('\n');

        foreach (string line in lines)
        {
            // Split the line into columns using the tab character
            string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
            Console.WriteLine("Row:");

            foreach (string column in columns)
            {
                Console.WriteLine("  " + column); // Output each column in the row
            }
        }
    }
}

using IronPDF;
using System;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("table.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Split the text into lines (rows)
        string[] lines = text.Split('\n');

        foreach (string line in lines)
        {
            // Split the line into columns using the tab character
            string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
            Console.WriteLine("Row:");

            foreach (string column in columns)
            {
                Console.WriteLine("  " + column); // Output each column in the row
            }
        }
    }
}

Imports Microsoft.VisualBasic
Imports IronPDF
Imports System
Imports System.Linq

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the PDF document
		Dim pdf As PdfDocument = PdfDocument.FromFile("table.pdf")

		' Extract all text from the PDF
		Dim text As String = pdf.ExtractAllText()

		' Split the text into lines (rows)
		Dim lines() As String = text.Split(ControlChars.Lf)

		For Each line As String In lines
			' Split the line into columns using the tab character
			Dim columns() As String = line.Split(ControlChars.Tab).Where(Function(col) Not String.IsNullOrWhiteSpace(col)).ToArray()
			Console.WriteLine("Row:")

			For Each column As String In columns
				Console.WriteLine("  " & column) ' Output each column in the row
			Next column
		Next line
	End Sub
End Class

Dans cet exemple, nous avons suivi les mêmes étapes qu'auparavant pour charger notre document PDF et extraire le texte. Ensuite, en utilisant text.Split('\n') nous divisons le texte extrait en lignes en fonction des sauts de ligne et stockons les résultats dans le tableau lines. Une boucle foreach est ensuite utilisée pour parcourir les lignes du tableau, où line.Split('\t') est utilisé pour diviser encore plus les lignes en colonnes à l'aide du caractère de tabulation '\t' comme délimiteur. La prochaine partie du tableau de colonnes, Where(col => !string.IsNullOrWhiteSpace(col)).ToArray() filtre les colonnes vides qui peuvent apparaître à cause d'espaces supplémentaires, puis ajoute les colonnes au tableau des colonnes.

Enfin, nous écrivons le texte dans la fenêtre de sortie de la console avec une structure de base pour les lignes et les colonnes.

Exporter les données tabulaires extraites vers CSV

Maintenant que nous avons couvert comment extraire des tableaux à partir de fichiers PDF, examinons ce que nous pouvons faire avec ces données extraites. Exporter le tableau extrait sous forme de fichier CSV est un moyen utile de gérer les données tabulaires et d'automatiser des tâches telles que la saisie de données. Pour cet exemple, nous avons rempli un tableau avec des données simulées, dans ce cas, la quantité de pluie quotidienne en une semaine, extrait le tableau du PDF, puis exporté celui-ci vers un fichier CSV.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        string pdfPath = "table.pdf";
        string csvPath = "output.csv";

        // Extract and parse table data
        var tableData = ExtractTableDataFromPdf(pdfPath);

        // Write the extracted data to a CSV file
        WriteDataToCsv(tableData, csvPath);
        Console.WriteLine($"Data extracted and saved to {csvPath}");
    }

    static List<string[]> ExtractTableDataFromPdf(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // Extract text from the first page
        var text = pdf.ExtractTextFromPage(0); 
        var rows = new List<string[]>();

        // Split text into lines (rows)
        var lines = text.Split('\n');

        // Variable to hold column values temporarily
        var tempColumns = new List<string>();

        foreach (var line in lines)
        {
            var trimmedLine = line.Trim();

            // Check for empty lines or lines that don't contain table data
            if (string.IsNullOrEmpty(trimmedLine) || trimmedLine.Contains("Header"))
            {
                continue;
            }

            // Split line into columns. Adjust this based on how columns are separated.
            var columns = trimmedLine.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);

            if (columns.Length > 0)
            {
                // Add columns to temporary list
                tempColumns.AddRange(columns);
                rows.Add(tempColumns.ToArray());
                tempColumns.Clear(); // Clear temporary list after adding to rows
            }
        }

        return rows;
    }

    static void WriteDataToCsv(List<string[]> data, string csvPath)
    {
        using (var writer = new StreamWriter(csvPath))
        {
            foreach (var row in data)
            {
                // Join columns with commas and quote each field to handle commas within data
                var csvRow = string.Join(",", row.Select(field => $"\"{field.Replace("\"", "\"\"")}\""));
                writer.WriteLine(csvRow);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        string pdfPath = "table.pdf";
        string csvPath = "output.csv";

        // Extract and parse table data
        var tableData = ExtractTableDataFromPdf(pdfPath);

        // Write the extracted data to a CSV file
        WriteDataToCsv(tableData, csvPath);
        Console.WriteLine($"Data extracted and saved to {csvPath}");
    }

    static List<string[]> ExtractTableDataFromPdf(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);

        // Extract text from the first page
        var text = pdf.ExtractTextFromPage(0); 
        var rows = new List<string[]>();

        // Split text into lines (rows)
        var lines = text.Split('\n');

        // Variable to hold column values temporarily
        var tempColumns = new List<string>();

        foreach (var line in lines)
        {
            var trimmedLine = line.Trim();

            // Check for empty lines or lines that don't contain table data
            if (string.IsNullOrEmpty(trimmedLine) || trimmedLine.Contains("Header"))
            {
                continue;
            }

            // Split line into columns. Adjust this based on how columns are separated.
            var columns = trimmedLine.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);

            if (columns.Length > 0)
            {
                // Add columns to temporary list
                tempColumns.AddRange(columns);
                rows.Add(tempColumns.ToArray());
                tempColumns.Clear(); // Clear temporary list after adding to rows
            }
        }

        return rows;
    }

    static void WriteDataToCsv(List<string[]> data, string csvPath)
    {
        using (var writer = new StreamWriter(csvPath))
        {
            foreach (var row in data)
            {
                // Join columns with commas and quote each field to handle commas within data
                var csvRow = string.Join(",", row.Select(field => $"\"{field.Replace("\"", "\"\"")}\""));
                writer.WriteLine(csvRow);
            }
        }
    }
}

Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Linq
Imports IronPDF

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfPath As String = "table.pdf"
		Dim csvPath As String = "output.csv"

		' Extract and parse table data
		Dim tableData = ExtractTableDataFromPdf(pdfPath)

		' Write the extracted data to a CSV file
		WriteDataToCsv(tableData, csvPath)
		Console.WriteLine($"Data extracted and saved to {csvPath}")
	End Sub

	Private Shared Function ExtractTableDataFromPdf(ByVal pdfPath As String) As List(Of String())
		Dim pdf = PdfDocument.FromFile(pdfPath)

		' Extract text from the first page
		Dim text = pdf.ExtractTextFromPage(0)
		Dim rows = New List(Of String())()

		' Split text into lines (rows)
		Dim lines = text.Split(ControlChars.Lf)

		' Variable to hold column values temporarily
		Dim tempColumns = New List(Of String)()

		For Each line In lines
			Dim trimmedLine = line.Trim()

			' Check for empty lines or lines that don't contain table data
			If String.IsNullOrEmpty(trimmedLine) OrElse trimmedLine.Contains("Header") Then
				Continue For
			End If

			' Split line into columns. Adjust this based on how columns are separated.
			Dim columns = trimmedLine.Split( { " "c, ControlChars.Tab }, StringSplitOptions.RemoveEmptyEntries)

			If columns.Length > 0 Then
				' Add columns to temporary list
				tempColumns.AddRange(columns)
				rows.Add(tempColumns.ToArray())
				tempColumns.Clear() ' Clear temporary list after adding to rows
			End If
		Next line

		Return rows
	End Function

	Private Shared Sub WriteDataToCsv(ByVal data As List(Of String()), ByVal csvPath As String)
		Using writer = New StreamWriter(csvPath)
			For Each row In data
				' Join columns with commas and quote each field to handle commas within data
				Dim csvRow = String.Join(",", row.Select(Function(field) $"""{field.Replace("""", """""")}"""))
				writer.WriteLine(csvRow)
			Next row
		End Using
	End Sub
End Class

Conseils et meilleures pratiques

Lorsque vous travaillez avec des tableaux PDF, suivre quelques pratiques élémentaires peut aider à minimiser les chances de rencontrer des erreurs ou des problèmes.

• Prétraiter les PDF : Si possible, prétraitez vos PDF pour garantir un formatage cohérent, ce qui simplifie le processus d'extraction.
• Valider les données : Validez toujours les données extraites pour assurer leur exactitude et leur exhaustivité.
• Gérer les erreurs : Implémentez la gestion des erreurs pour gérer les cas où l'extraction ou l'analyse du texte échoue, comme en encapsulant votre code dans un bloc try-catch.
• Optimiser les performances : Pour les fichiers PDF volumineux, envisagez d'optimiser l'extraction et l'analyse de texte pour gérer les problèmes de performances.

Licences IronPDF

IronPDF propose différentes options de licence, vous permettant d'essayer toutes les fonctionnalités puissantes d'IronPDF avant de vous engager dans une licence.

Conclusion

Extraire des tableaux à partir de PDF en utilisant IronPDF est un moyen puissant d'automatiser l'extraction de données, faciliter l'analyse et convertir des documents en formats plus accessibles. Que vous traitiez de tableaux simples ou de formats complexes et irréguliers, IronPDF fournit les outils nécessaires pour extraire et traiter efficacement les données tabulaires.

Avec IronPDF, vous pouvez rationaliser des flux de travail comme la saisie automatique de données, la conversion de documents et l'analyse de données. La flexibilité et les fonctionnalités avancées offertes par IronPDF en font un outil précieux pour gérer diverses tâches basées sur les PDF.