Comment extraire texte de tableaux dans des documents PDF en C# avec IronOCR
IronOCR, logiciel OCR pour .NET, permet aux développeurs C# d'extraire texte et données de tableaux dans des PDF et des images à l'aide de modèles d'apprentissage automatique avancés, gérant à la fois des tableaux simples avec des cellules de base et des structures complexes comme des factures avec des cellules fusionnées à l'aide de la méthode ReadDocumentAdvanced.
L'extraction de données à partir de tableaux à l'aide de Tesseract peut s'avérer difficile, car le texte se trouve souvent dans des cellules et est peu dispersé dans le document. Toutefois, notre bibliothèque comprend un modèle d'apprentissage automatique formé et affiné pour détecter et extraire avec précision les données des tableaux. Qu'il s'agisse de traiter des rapports financiers, des listes d'inventaire ou des données de facturation, IronOCR fournit les outils nécessaires pour analyser efficacement les données structurées.
Pour les tableaux simples, utilisez la détection de tableau simple à l'aide de la classe standard OcrInput . Pour les structures plus complexes, notre méthode exclusive ReadDocumentAdvanced fournit des résultats robustes, analysant efficacement les tables et fournissant des données. Cette méthode avancée s'appuie sur l'apprentissage automatique pour comprendre la disposition des tableaux, les cellules fusionnées et le formatage complexe qui pose souvent problème à l'OCR traditionnel.
Démarrage rapide : Extraire des cellules de tableau complexes en un seul appel
Soyez opérationnel en quelques minutes : cet exemple montre comment un seul appel IronOCR utilisant ReadDocumentAdvanced vous donne 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.
-
Installez IronOCR avec le Gestionnaire de Packages NuGet
PM > Install-Package IronOcr -
Copiez et exécutez cet extrait de code.
var cells = new IronTesseract().ReadDocumentAdvanced(new OcrInput().LoadPdf("invoiceTable.pdf")).Tables.First().CellInfos; -
Déployez pour tester sur votre environnement de production.
Commencez à utiliser IronOCR dans votre projet dès aujourd'hui avec un essai gratuit
Les étapes suivantes vous guideront pour commencer à lire des tableaux à l'aide d'IronOCR :
Flux de travail minimal (5 étapes)
- Téléchargez une bibliothèque C# pour extraire des données à partir de tables.
- Préparez l'image et le document PDF pour l'extraction
- Définissez la propriété `ReadDataTables` sur true pour activer la détection des tableaux
- Utilisez la méthode `ReadDocumentAdvanced` pour les tables complexes.
- Extrayez les données détectées par ces méthodes
Comment extraire des données de tableaux simples ?
Définir la propriété ReadDataTables sur true active la détection de table à 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();
}
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
Comment lire des tableaux de factures complexes?
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 que le package IronOcr.Extensions.AdvancedScan soit installé en plus du package de base IronOCR . Cette extension offre des capacités avancées d'apprentissage automatique spécialement formées pour les mises en page de documents complexes.
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."
: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;
Imports IronOcr
Imports System.Linq
' Instantiate OCR engine
Dim ocr = New IronTesseract()
Using input As New OcrInput()
input.LoadPdf("invoiceTable.pdf")
' Perform OCR
Dim result = ocr.ReadDocumentAdvanced(input)
Dim cellList = result.Tables.First().CellInfos
End Using
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?
Comment organiser et traiter les cellules de tableau extraites ?
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. Les informations de la cellule comprennent :
- Coordonnées X/Y précises pour le positionnement
- Dimensions en largeur et en hauteur
- Contenu du texte
- Notes de confiance
- Relations cellulaires
Ces informations détaillées vous permettent de reconstruire la structure du tableau par programme et d'appliquer une logique personnalisée pour l'extraction des données. Vous pouvez également utiliser ces coordonnées pour définir des régions spécifiques en vue d'un traitement ROC ciblé lors d'opérations ultérieures.
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
Bonnes pratiques pour l'extraction de tableaux
Lorsque vous travaillez avec l'extraction de tableaux dans IronOcr, tenez compte de ces meilleures pratiques :
-
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.
-
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.
-
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.
-
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.
- 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 dans les documents complexes comme 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.
Questions Fréquemment Posées
Comment extraire des données de tableaux à partir de PDF et d'images en C# ?
IronOcr permet aux développeurs C# d'extraire des données de tableaux à partir de PDF et d'images à l'aide de modèles d'apprentissage automatique avancés. Pour les tableaux simples, utilisez la classe OcrInput avec la propriété ReadDataTables fixée à true. Pour les tableaux complexes avec des cellules fusionnées, utilisez la méthode ReadDocumentAdvanced pour obtenir des résultats plus précis.
Quelle est la différence entre une extraction de tableau simple et une extraction de tableau complexe ?
L'extraction simple de tableaux dans IronOcr utilise la propriété ReadDataTables avec Tesseract et fonctionne bien pour les tableaux de base avec des limites de cellules claires. L'extraction de tableaux complexes nécessite la méthode ReadDocumentAdvanced, qui utilise l'apprentissage automatique pour gérer les cellules fusionnées, les factures et le formatage complexe.
Comment extraire rapidement des données de tableaux complexes ?
Utilisez la méthode ReadDocumentAdvanced d'IronOcr en un seul appel : var cells = new IronTesseract().ReadDocumentAdvanced(new OcrInput().LoadPdf('invoiceTable.pdf')).Tables.First().CellInfos ; Cela tire parti de l'apprentissage automatique pour comprendre les mises en page des tableaux et les formatages complexes.
Quels sont les types de documents qui fonctionnent le mieux avec la détection de tableaux simples ?
La méthode simple de détection des tableaux d'IronOcr fonctionne particulièrement bien avec les exportations de feuilles de calcul, les tableaux de données de base avec une structure de lignes/colonnes cohérente, les rapports avec des données tabulaires et les listes d'inventaire simples sans cellules fusionnées.
Comment activer la détection des tableaux de base ?
Pour activer la détection des tables dans IronOcr pour les tables de base, définissez la propriété ReadDataTables sur true. Cela utilise les capacités de détection de tableaux de Tesseract et fonctionne bien pour les tableaux avec des limites de cellules claires et sans cellules fusionnées.
La bibliothèque peut-elle traiter des factures et des rapports financiers avec des mises en page complexes ?
Oui, la méthode ReadDocumentAdvanced d'IronOcr est spécifiquement conçue pour traiter des documents complexes tels que des factures et des rapports financiers. Elle utilise des modèles d'apprentissage automatique formés à la détection et à l'extraction de données à partir de tableaux comportant des cellules fusionnées et un formatage complexe.

