Comment lire des tableaux dans des documents avec C#

Updated: 29 juin 2026

IronOCR permet aux développeurs C# d'extraire des données de tables dans des PDFs et des images en utilisant des modèles avancés d'apprentissage automatique, traitant à la fois des tables simples avec des cellules de base et des structures complexes comme des factures avec cellules fusionnées en utilisant 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 tables simples, comptez sur la détection de table directe en utilisant la classe standard OcrInput. Pour les structures plus complexes, notre méthode exclusive ReadDocumentAdvanced fournit des résultats robustes, analysant efficacement les tables et livrant les 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 les cellules de tableau complexes en un seul appel

Mettez-vous en service en quelques minutes — cet exemple montre comment un seul appel IronOCR utilisant ReadDocumentAdvanced vous donne des données de cellule de table détaillées à 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.

1Install IronOCR with NuGet Package Manager
PM > Install-Package IronOcr
```
Install-Package IronOcr
```

2Copiez et exécutez cet extrait de code.

var input = new OcrInput();
input.LoadPdf("invoiceTable.pdf");
var cells = new IronTesseract().ReadDocumentAdvanced(input).Tables.First().CellInfos;

var input = new OcrInput();
input.LoadPdf("invoiceTable.pdf");
var cells = new IronTesseract().ReadDocumentAdvanced(input).Tables.First().CellInfos;

3Dé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 permet la détection de table en utilisant 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 basiques avec une structure de 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.

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();
}

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

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 exige 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.

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 : "Advanced Scan on .NET Framework."
)}]

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;

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

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?

OCR d'Iron Software extrayant des données de tableau de facture d'expédition au format structuré hiérarchique

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

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 tables simples, tandis que la méthode ReadDocumentAdvanced excelle avec des documents complexes comme des 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.

Is it possible to organize extracted table cells based on coordinates using IronOCR?

Yes, IronOCR provides detailed information for each extracted cell, including its coordinates. You can use this data to organize cells programmatically by sorting them based on X and Y coordinates, allowing for precise reconstruction of the table structure.

What document quality is recommended for optimal results when using IronOCR for table extraction?

For optimal results, it is recommended to use documents with a minimum resolution of 300 DPI. Higher quality documents improve the accuracy of the OCR process and result in better table extraction outcomes.

Can IronOCR process tables in multi-page documents effectively?

Yes, IronOCR can process tables in multi-page documents effectively. It supports parallel processing using multithreading and async support to handle large documents with multiple tables efficiently.

What output options does IronOCR provide after extracting table data?

IronOCR provides several output options after extracting table data, including exporting results in various formats and creating searchable PDFs. Explore its data output options to suit your needs.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

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 et créer des manuels bien structurés et visuellement attrayants.

...