Tabellen lesen und PDF Text extrahieren – IronOCR Texterkennung für Dokumente
IronOCR ermöglicht es C#-Entwicklern, Daten aus Tabellen in PDFs und Bildern mithilfe fortschrittlicher Modelle des maschinellen Lernens zu extrahieren und PDF Text zu extrahieren. Dabei werden sowohl einfache Tabellen als auch komplexe Strukturen wie Rechnungen mit zusammengeführten Zellen mithilfe der Methode ReadDocumentAdvanced verarbeitet.
Das Extrahieren von Daten aus Tabellen mit einfachem Tesseract kann eine Herausforderung sein, da sich der Text oft in Zellen befindet und nur spärlich über das Dokument verteilt ist. Unsere Bibliothek enthält jedoch ein maschinelles Lernmodell, das für die genaue Erkennung und Extraktion von Tabellendaten trainiert und abgestimmt wurde. Ob es um die Verarbeitung von Finanzberichten, Inventarlisten oder Rechnungsdaten geht, IronOCR bietet die Werkzeuge, um strukturierte Daten effizient zu analysieren.
Bei einfachen Tabellen kann auf die unkomplizierte Tabellenerkennung mithilfe der Standardklasse OcrInput zurückgegriffen werden. Für komplexere Strukturen liefert unsere exklusive ReadDocumentAdvanced Methode robuste Ergebnisse, indem sie Tabellen effektiv analysiert und Daten liefert. Diese fortschrittliche Methode nutzt das maschinelle Lernen, um Tabellenlayouts, zusammengeführte Zellen und komplexe Formatierungen zu verstehen, mit denen herkömmliche OCR oft Probleme hat.
Schnellstart: Komplexe Tabellenzellen in einem Aufruf extrahieren
In wenigen Minuten startklar – dieses Beispiel zeigt, wie ein einziger IronOCR Aufruf mit ReadDocumentAdvanced Ihnen detaillierte Tabellenzellendaten aus einem komplexen Dokument liefert.
Es demonstriert die Benutzerfreundlichkeit, indem es ein PDF lädt, eine erweiterte Tabellenerkennung anwendet und eine Liste von Zellinformationen direkt zurückgibt.
-
Installieren Sie IronOCR mit NuGet Package Manager
PM > Install-Package IronOcr -
Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.
var cells = new IronTesseract().ReadDocumentAdvanced(new OcrInput().LoadPdf("invoiceTable.pdf")).Tables.First().CellInfos; -
Bereitstellen zum Testen in Ihrer Live-Umgebung
Beginnen Sie noch heute, IronOCR in Ihrem Projekt zu verwenden, mit einer kostenlosen Testversion
Die folgenden Schritte führen Sie in die ersten Schritte zum Lesen von Tabellen mit IronOCR ein:
Minimaler Arbeitsablauf (5 Schritte)
- Laden Sie eine C#-Bibliothek herunter, um Daten aus Tabellen zu extrahieren.
- Bereiten Sie das Bild- und PDF-Dokument zur Extraktion vor
- Setzen Sie die Eigenschaft `ReadDataTables` auf true, um die Tabellenerkennung zu aktivieren
- Verwenden Sie die `ReadDocumentAdvanced` Methode für komplexe Tabellen.
- Extrahieren Sie die von diesen Methoden erkannten Daten
Wie kann ich Daten aus einfachen Tabellen extrahieren?
Durch Setzen der Eigenschaft ReadDataTables auf true wird die Tabellenerkennung mit Tesseract aktiviert. Dieser Ansatz eignet sich gut für einfache Tabellen mit klaren Zellgrenzen und ohne verschmolzene Zellen. Ich habe ein einfaches Tabellen-PDF erstellt, um diese Funktion zu testen, das Sie hier herunterladen können: 'simple-table.pdf'. Einfache Tabellen ohne zusammengeführte Zellen können mit dieser Methode erkannt werden. Für komplexere Tabellen wenden Sie bitte die unten beschriebene Methode an.
Die Standard-Tabellenerkennungsmethode ist besonders effektiv für:
- Tabellenkalkulationsexporte
- Grunddatentabellen mit einheitlicher Zeilen-/Spaltenstruktur
- Berichte mit tabellarischen Daten
- Einfache Inventarlisten
Wenn Sie mit PDF OCR Textextraktion im Allgemeinen arbeiten, lässt sich diese Methode nahtlos in die breiteren Dokumentverarbeitungsfunktionen von IronOCR integrieren.
: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
Wie kann ich komplexe Rechnungstabellen lesen?
Eine der häufigsten komplexen Tabellen in Geschäftsumgebungen sind Rechnungen. Rechnungen sind komplexe Tabellen mit Datenzeilen und -spalten, oft mit verschmolzenen Zellen, unterschiedlichen Spaltenbreiten und verschachtelten Strukturen. Mit IronOCR nutzen wir die ReadDocumentAdvanced-Methode, um sie effektiv zu verarbeiten. Der Prozess umfasst das Scannen des Dokuments, die Identifikation der Tabellenstruktur und die Datenextraktion. In diesem Beispiel verwenden wir die Datei "invoiceTable.pdf", um zu zeigen, wie IronOCR alle Informationen aus der Rechnung abruft.
Die Methode ReadDocumentAdvanced erfordert, dass das Paket IronOcr.Extensions.AdvancedScan zusammen mit dem Basispaket IronOCR installiert wird. Diese Erweiterung bietet fortschrittliche maschinelle Lernfunktionen, die speziell für komplexe Dokumentenlayouts trainiert wurden.
[{ich:(
Die erweiterte Abtastung auf dem .NET Framework erfordert, dass das Projekt auf der x64-Architektur ausgeführt wird. Navigieren Sie zur Projektkonfiguration und deaktivieren Sie die Option "Bevorzugt 32-Bit", um dies zu erreichen. Erfahren Sie mehr in der folgenden Anleitung zur Fehlerbehebung: "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
Diese Methode trennt die Textdaten des Dokuments in zwei Kategorien: eine eingekapselt von Rändern und eine andere ohne Ränder. Für die mit Rahmen versehenen Inhalte teilt die Bibliothek sie weiter in Unterabschnitte basierend auf der Tabellenstruktur auf. Die Methode zeichnet sich durch die Handhabung aus:
- Rechnungspositionen mit unterschiedlichen Beschreibungen
- Mehrspaltige Preisaufschlüsselungen
- Blöcke für Versand- und Rechnungsadresse
- Abschnitte zur Steuer- und Gesamtberechnung
- Kopf- und Fußzeileninformationen
Die Ergebnisse werden unten angezeigt. Da sich diese Methode auf Informationen konzentriert, die von Grenzen umschlossen sind, werden alle zusammengeführten Zellen, die sich über mehrere Zeilen erstrecken, als eine einzige Zelle behandelt.
Wie sehen die extrahierten Daten aus?
Wie organisiere und verarbeite ich die extrahierten Tabellenzellen?
In der aktuellen Implementation sind die extrahierten Zellen noch nicht richtig organisiert. Jede Zelle enthält jedoch wertvolle Informationen wie X- und Y-Koordinaten, Abmessungen und mehr. Mit diesen Daten können wir eine Hilfsklasse für verschiedene Zwecke erstellen. Die Zellinformationen umfassen:
- Präzise X/Y-Koordinaten für die Positionierung
- Abmessungen für Breite und Höhe
- Inhalt des Textes
- Konfidenzwerte
- Beziehungen zwischen Zellen
Diese detaillierten Informationen ermöglichen es Ihnen, die Tabellenstruktur programmatisch zu rekonstruieren und eine benutzerdefinierte Logik für die Datenextraktion anzuwenden. Sie können diese Koordinaten auch verwenden, um bestimmte Regionen für eine gezielte OCR-Verarbeitung in nachfolgenden Operationen zu definieren.
Hier sind einige grundlegende Hilfsmethoden:
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
Best Practices für die Tabellenextraktion
Beachten Sie bei der Arbeit mit der Tabellenextraktion in IronOCR die folgenden Best Practices:
-
Dokumentenqualität: Höher aufgelöste Dokumente liefern bessere Ergebnisse. Achten Sie bei gescannten Dokumenten auf eine Mindestauflösung von 300 DPI.
-
Vorbearbeitung: Bei Dokumenten mit schlechter Qualität oder schiefen Tabellen sollten Sie die Bildkorrekturfunktionen von IronOCR vor der Verarbeitung verwenden.
-
Leistungsfähigkeit: Bei großen Dokumenten mit mehreren Tabellen sollten Sie Multithreading und async-Unterstützung verwenden, um Seiten parallel zu verarbeiten.
-
Ausgabeoptionen: Nach der Extraktion von Tabellendaten können Sie die Ergebnisse in verschiedenen Formaten exportieren. Erfahren Sie mehr über Datenausgabeoptionen und wie Sie durchsuchbare PDFs aus Ihren verarbeiteten Dokumenten erstellen.
- Stream Processing: Für Webanwendungen oder Szenarien, die mit In-Memory-Dokumenten arbeiten, sollten Sie OCR für PDF-Streams verwenden, um Dateisystemoperationen zu vermeiden.
Zusammenfassung
IronOCR bietet leistungsstarke Funktionen zur Tabellenextraktion, sowohl durch standardmäßige Tesseract-basierte Erkennung als auch durch fortschrittliche maschinelle Lernmethoden. Der Standardansatz eignet sich gut für einfache Tabellen, während die ReadDocumentAdvanced Methode bei komplexen Dokumenten wie Rechnungen hervorragende Ergebnisse liefert. Mit den bereitgestellten Hilfsmethoden können Sie die extrahierten Daten organisieren und verarbeiten, um sie an Ihre spezifischen Bedürfnisse anzupassen.
Entdecken Sie weitere IronOCR-Funktionen, um Ihre Dokumentenverarbeitungs-Workflows zu verbessern und das volle Potenzial der optischen Zeichenerkennung in Ihren .NET-Anwendungen zu nutzen.
Häufig gestellte Fragen
Wie kann ich in C# Tabellendaten aus PDFs und Bildern extrahieren?
IronOCR ermöglicht C#-Entwicklern die Extraktion von Tabellendaten aus PDFs und Bildern mithilfe fortschrittlicher maschineller Lernmodelle. Für einfache Tabellen verwenden Sie die Klasse OcrInput mit der Eigenschaft ReadDataTables, die auf true gesetzt ist. Für komplexe Tabellen mit zusammengeführten Zellen verwenden Sie die ReadDocumentAdvanced-Methode, um genauere Ergebnisse zu erzielen.
Was ist der Unterschied zwischen einer einfachen und einer komplexen Tabellenextraktion?
Die einfache Tabellenextraktion in IronOCR verwendet die ReadDataTables-Eigenschaft mit Tesseract und funktioniert gut für einfache Tabellen mit klaren Zellgrenzen. Komplexe Tabellenextraktion erfordert die ReadDocumentAdvanced-Methode, die maschinelles Lernen verwendet, um verbundene Zellen, Rechnungen und komplexe Formatierungen zu verarbeiten.
Wie kann ich schnell Daten aus komplexen Tabellen extrahieren?
Verwenden Sie die ReadDocumentAdvanced-Methode von IronOCR in einem einzigen Aufruf: var cells = new IronTesseract().ReadDocumentAdvanced(new OcrInput().LoadPdf('invoiceTable.pdf')).Tables.First().CellInfos; Damit wird maschinelles Lernen genutzt, um Tabellenlayouts und komplexe Formatierungen zu verstehen.
Welche Arten von Dokumenten eignen sich am besten für die einfache Tabellenerkennung?
Die einfache Tabellenerkennungsmethode von IronOCR funktioniert besonders gut bei Tabellenkalkulationsexporten, einfachen Datentabellen mit konsistenter Zeilen-/Spaltenstruktur, Berichten mit Tabellendaten und einfachen Bestandslisten ohne verbundene Zellen.
Wie kann ich die Tabellenerkennung für einfache Tabellen aktivieren?
Um die Tabellenerkennung in IronOCR für einfache Tabellen zu aktivieren, setzen Sie die Eigenschaft ReadDataTables auf true. Dies nutzt die Tabellenerkennungsfunktionen von Tesseract und funktioniert gut bei Tabellen mit klaren Zellgrenzen und ohne verschmolzene Zellen.
Kann die Bibliothek Rechnungen und Finanzberichte mit komplexen Layouts verarbeiten?
Ja, die ReadDocumentAdvanced-Methode von IronOCR wurde speziell für die Bearbeitung komplexer Dokumente wie Rechnungen und Finanzberichte entwickelt. Sie verwendet maschinelle Lernmodelle, die darauf trainiert sind, Daten aus Tabellen mit verbundenen Zellen und komplexen Formatierungen zu erkennen und zu extrahieren.

