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

Dans de nombreux secteurs, les fichiers PDF sont le format de prédilection pour partager des documents structurés tels que des rapports, des factures et des tableaux de données. Cependant, l'extraction de données à partir de PDF, en particulier lorsqu'il s'agit de tableaux, peut s'avérer difficile en raison de la nature du format PDF. Contrairement aux formats de données structurées, les PDF sont principalement conçus pour la présentation et non pour l'extraction de données.

Cependant, avecIronPDFgrâce à la bibliothèque C# PDF .NET, vous pouvez facilement extraire des données structurées telles que des tableaux directement à partir de PDF et les traiter dans vos applications .NET. Cet article vous guidera pas à pas sur la manière d'extraire des données tabulaires de fichiers PDF à l'aide d'IronPDF.

Quand avez-vous besoin d'extraire des tableaux de documents PDF ?

Les tableaux sont un moyen pratique de structurer et d'afficher vos données, qu'il s'agisse de gérer des stocks, de saisir des données, d'enregistrer des données telles que les précipitations, etc. Il peut donc y avoir de nombreuses raisons d'extraire des tableaux et des données de tableaux à partir de documents PDF. Parmi les cas d'utilisation les plus courants, citons

• **L'extraction de données à partir de tableaux dans des rapports PDF ou des factures peut automatiser des processus tels que l'alimentation 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 de tableaux vous permet d'analyser ces données de manière programmatique.
• Conversion de documents: L'extraction de données tabulaires dans des formats plus accessibles tels qu'Excel ou CSV facilite la manipulation, le stockage et le partage.
• Audit et conformité: Pour les documents juridiques ou financiers, l'extraction programmatique 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 pas la possibilité de stocker des données dans des formats structurés tels que des tableaux. Le tableau que nous utilisons dans l'exemple d'aujourd'hui a été créé en HTML, avant d'êtreconverti au format PDF. Les tableaux sont rendus sous forme de texte et de lignes, de sorte que l'extraction des données des tableaux nécessite souvent une analyse et une interprétation du contenu, à moins que vous n'utilisiez un logiciel de reconnaissance optique de caractères (OCR), tel queIronOCR.

Comment extraire les données d'un tableau à partir d'un fichier PDF dans C# ;

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

1. Accéder à l'outil d'extraction PDF en ligne gratuit

2. Télécharger le PDF contenant le tableau

3. Voir et télécharger les résultats

Première étape : naviguer vers l'outil d'extraction PDF en ligne gratuit

Aujourd'hui, nous allons utiliserDocsumo comme notre exemple d'outil PDF en ligne. Docsumo est un outil d'analyse de documents PDF en ligne qui propose un outil gratuit d'extraction de tableaux PDF.

Deuxième étape : télécharger le PDF contenant le tableau

Cliquez maintenant sur le bouton "Charger un fichier" pour télécharger votre fichier PDF en vue de son extraction. L'outil commencera immédiatement à traiter votre PDF.

Troisième étape : Visualiser et télécharger les résultats

Une fois que Docsumo a terminé le traitement du PDF, il affiche le tableau extrait. Vous pouvez ensuite apporter des modifications à la structure du tableau, par exemple en ajoutant ou en supprimant des lignes. Ici, vous pouvez télécharger le tableau au format PDF, XLS, JSON ou texte.

Extraire les données d'un tableau à l'aide d'IronPDF

IronPDF permet d'extraire des données, du texte et des graphiques des PDF, qui peuvent ensuite être utilisés pour reconstruire des tableaux de manière programmatique. Pour ce faire, vous devrez d'abord extraire le contenu textuel du tableau dans le PDF, puis utiliser ce texte pour analyser le tableau en lignes et en colonnes. Avant de commencer à extraire des tableaux, examinons comment IronPDF peut être utilisé dans le cadre d'un projet de traductionExtraire tout le texte() la méthode de calcul de la valeur ajoutée permet d'extraire les données d'un tableau :

using IronPDF;
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
string text = pdf.ExtractAllText();
Console.WriteLine(text);

using IronPDF;
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
string text = pdf.ExtractAllText();
Console.WriteLine(text);

Imports IronPDF
Private pdf As PdfDocument = PdfDocument.FromFile("example.pdf")
Private text As String = pdf.ExtractAllText()
Console.WriteLine(text)

Dans cet exemple, nous avons chargé le document PDF à l'aide de la commandePdfDocument l'auteur de la traduction a créé une classe de texte, puis a utilisé la fonction ExtractAllText() La traduction doit rester professionnelle, en préservant la précision technique tout en expliquant les caractéristiques et les avantages de ces outils de développement.

Extraction de données de tableau à partir de texte à l'aide d'IronPDF

Après avoir extrait le texte du PDF, le tableau apparaîtra sous la forme d'une série de lignes et de colonnes en texte brut. Vous pouvez diviser ce texte en fonction des sauts de ligne(\n) la traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Voici un exemple de base de l'analyse du tableau à partir du texte :

using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("table.pdf");
string text = pdf.ExtractAllText();
string[] lines = text.Split('\n');
foreach (string line in lines)
{
    string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
    Console.WriteLine("Row: ");
    foreach (string column in columns)
    {
        Console.WriteLine("  " + column);
    }
}

using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("table.pdf");
string text = pdf.ExtractAllText();
string[] lines = text.Split('\n');
foreach (string line in lines)
{
    string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
    Console.WriteLine("Row: ");
    foreach (string column in columns)
    {
        Console.WriteLine("  " + column);
    }
}

Imports Microsoft.VisualBasic
Imports IronPdf
Private pdf As PdfDocument = PdfDocument.FromFile("table.pdf")
Private text As String = pdf.ExtractAllText()
Private lines() As String = text.Split(ControlChars.Lf)
For Each line As String In lines
	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)
	Next column
Next line

Dans cet exemple, nous avons suivi les mêmes étapes que précédemment 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 les lignes en colonnes en utilisant le caractère de tabulation '\t' comme délimiteur. La partie suivante du tableau de colonnes, Où(col =>!string.IsNullOrWhiteSpace(col)).ToArray() filtre les colonnes vides qui peuvent apparaître en raison d'espaces supplémentaires, puis ajoute les colonnes au tableau de colonnes.

Enfin, nous écrivons du texte dans la fenêtre de sortie de la console avec une structuration de base des lignes et des colonnes.

Exportation des données extraites d'un tableau vers un fichier CSV

Maintenant que nous avons vu comment extraire des tableaux de fichiers PDF, voyons ce que nous pouvons faire avec les données extraites. L'exportation du tableau exporté sous forme de fichier CSV est un moyen utile de traiter les données du tableau 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 au cours d'une semaine, extrait le tableau du PDF, puis l'avons exporté vers un fichier CSV.

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);
        var text = pdf.ExtractTextFromPage(0); // Extract text from the first page
        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);
            }
        }
    }
}

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);
        var text = pdf.ExtractTextFromPage(0); // Extract text from the first page
        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

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)
		Dim text = pdf.ExtractTextFromPage(0) ' Extract text from the first page
		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) 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

Exemple de fichier PDF

Fichier CSV de sortie

Comme vous pouvez le constater, nous avons réussi à exporter le tableau PDF au format CSV. Tout d'abord, nous avons chargé le PDF contenant le tableau et créé un nouveau chemin d'accès au fichier CSV. Ensuite, nous avons extrait le tableau à l'aide de la méthode var tableData = ExtractTableDataFromPdf(pdfPath) La ligne ExtractTableDataFromPdf() méthode. Cette méthode permet d'extraire tout le texte de la page PDF sur laquelle se trouve le tableau et de le stocker dans la variable text.

Ensuite, nous divisons le texte en lignes et en colonnes. Enfin, après avoir renvoyé le résultat de ce processus de fractionnement, nous appelons la méthode static void WriteDataToCsv() qui prend le texte extrait et divisé et l'écrit dans notre fichier CSV à l'aide de StreamWriter.

Conseils et bonnes pratiques

Lorsque vous travaillez avec des tableaux PDF, le respect de certaines bonnes pratiques de base peut vous aider à minimiser les risques d'erreurs ou de problèmes.

• Prétraiter les PDF: Si possible, pré-traitez vos PDF pour assurer un formatage cohérent, ce qui simplifie le processus d'extraction.
• Valider les données: Toujours valider les données extraites pour s'assurer qu'elles sont exactes et complètes.
• Gérer les erreurs: Mettre en œuvre une gestion des erreurs pour gérer les cas où l'extraction ou l'analyse de texte échoue, par exemple en enveloppant votre code dans un bloc try-catch.
• Optimiser les performances: Pour les PDF volumineux, envisagez d'optimiser l'extraction et l'analyse du texte afin de gérer les problèmes de performances.

Licences d'IronPDF

IronPDF offre différents services de traduction et d'interprétationoctroi de licences une version d'essai est disponible, vous permettant d'essayer par vous-même toutes les puissantes fonctionnalités qu'IronPDF a à offrir avant de vous engager dans une licence.

Conclusion

Extraction de tableaux à partir de PDF à l'aide deIronPDF l'utilisation d'un logiciel d'extraction de données est un moyen puissant d'automatiser l'extraction de données, de faciliter l'analyse et de convertir des documents dans des formats plus accessibles. Qu'il s'agisse de tableaux simples ou de formats complexes et irréguliers, IronPDF fournit les outils nécessaires pour extraire et traiter efficacement les données des tableaux.

Avec IronPDF, vous pouvez rationaliser les flux de travail tels que la saisie automatisée 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 traiter diverses tâches basées sur les PDF.