Jak wyodrębnić dane tabeli z pliku PDF w C#

Kiedy należy wydobywać tabele z dokumentów PDF?

Tabele to wygodny sposób strukturyzowania i wyświetlania danych, niezależnie od zarządzania inwentarzem, wprowadzania danych, rejestracji danych takich jak opady deszczu itp. Zatem może istnieć wiele powodów, dla których trzeba wydobywać tabele i dane tabelaryczne z dokumentów PDF. Niektóre z najczęstszych zastosowań to:

• Automatyzacja wprowadzania danych: Wydobycie danych z tabel w raportach PDF lub fakturach może zautomatyzować procesy, takie jak wypełnianie baz danych lub arkuszy kalkulacyjnych.
• Analiza danych: Firmy często otrzymują raporty w formacie PDF. Wydobycie tabel pozwala na programistyczną analizę tych danych.
• Konwersja dokumentów: Wydobycie danych tabelarycznych do bardziej dostępnych formatów, jak Excel czy CSV, umożliwia łatwiejszą manipulację, przechowywanie i udostępnianie.
• Audyt i zgodność: W przypadku dokumentów prawnych lub finansowych, programistyczne wydobycie danych tabelarycznych z dokumentów PDF może pomóc w automatyzacji audytów i zapewnieniu zgodności.

Jak działają tabele w formacie PDF?

Format pliku PDF nie oferuje natywnej możliwości przechowywania danych w uporządkowanych formatach, takich jak tabele. Tabela użyta w dzisiejszym przykładzie została stworzona w HTML, zanim została skonwertowana na format PDF. Tabele są renderowane jako tekst i linie, więc wydobycie danych tabelarycznych często wymaga analizy i interpretacji treści, chyba że używasz oprogramowania OCR, takiego jak IronOCR.

How to Extract Table Data from a PDF File in C

Zanim przyjrzymy się, jak IronPDF może poradzić sobie z tym zadaniem, najpierw przyjrzymy się narzędziu online zdolnemu do obsługi ekstrakcji PDF. Aby wyodrębnić tabelę z dokumentu PDF za pomocą narzędzia online, postępuj zgodnie z poniższymi krokami:

1. Przejdź do darmowego narzędzia online do ekstrakcji PDF
2. Prześlij plik PDF zawierający tabelę
3. Zobacz i pobierz wyniki

Wydobywanie danych tabelarycznych za pomocą IronPDF

IronPDF pozwala na wydobycie danych, tekstów i grafik z plików PDF, które można następnie wykorzystać do programistycznej rekonstrukcji tabel. Aby to zrobić, najpierw musisz wydobyć tekstową zawartość tabeli w pliku PDF, a następnie użyć tego tekstu do parsowania tabeli na wiersze i kolumny. Zanim zaczniemy wydobywać tabele, przyjrzyjmy się, jak działa metoda IronPDF ExtractAllText() poprzez wydobycie danych w tabeli:

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

W tym przykładzie załadowaliśmy dokument PDF za pomocą klasy PdfDocument, a następnie użyliśmy metody ExtractAllText() do wydobycia całego tekstu w dokumencie, a następnie wyświetliliśmy tekst na konsoli.

Wydobywanie danych tabelarycznych z tekstu za pomocą IronPDF

Po wydobyciu tekstu z pliku PDF tabela pojawi się jako seria wierszy i kolumn w tekście o prostym układzie. Możesz podzielić ten tekst na podstawie znaków nowej linii (\n), a następnie dalej podzielić wiersze na kolumny na podstawie spójnego odstępu lub separatorów, takich jak przecinki czy tabulatory. Oto podstawowy przykład, jak przeanalizować tabelę z tekstu:

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

W tym przykładzie postąpiliśmy według tych samych kroków co wcześniej, aby załadować nasz dokument PDF i wydobyć tekst. Następnie, używając text.Split('\n'), podzieliliśmy wydobyty tekst na wiersze, bazując na znakach nowej linii, i zapisaliśmy wyniki w tablicy lines. Pętla foreach jest następnie używana do przechodzenia przez wiersze w tablicy, gdzie line.Split('\t') jest używana do dalszego podziału wierszy na kolumny przy użyciu znaku tabulatora '\t' jako separatora. Kolejna część tablicy kolumn, Where(col => !string.IsNullOrWhiteSpace(col)).ToArray(), filtruje puste kolumny, które mogą powstać z powodu dodatkowych spacji, a następnie dodaje kolumny do tablicy kolumn.

W końcu zapisujemy tekst w oknie wyjścia konsoli z podstawową strukturą wierszy i kolumn.

Eksportowanie wydobytych danych tabelarycznych do CSV

Teraz, gdy omówiliśmy, jak wydobyć tabele z plików PDF, spójrzmy, co możemy zrobić z tymi wydobytymi danymi. Eksportowanie wydobytej tabeli jako pliku CSV to jeden z użytecznych sposobów obsługi danych tabelarycznych i automatyzacji zadań, takich jak wprowadzanie danych. W tym przykładzie wypełniliśmy tabelę danymi symulowanymi, w tym przypadku, ilością opadów dziennych w tygodniu, wydobyliśmy tabelę z pliku PDF, a następnie wyeksportowaliśmy ją do pliku 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

Wskazówki i najlepsze praktyki

Podczas pracy z tabelami w PDF, przestrzeganie kilku podstawowych najlepszych praktyk może pomóc w zminimalizowaniu szans na napotkanie błędów lub problemów.

• Wstępne przetwarzanie plików PDF: Jeśli to możliwe, wstępnie przetwórz swoje pliki PDF, aby zapewnić spójne formatowanie, co upraszcza proces ekstrakcji.
• Walidacja danych: Zawsze sprawdzaj poprawność wydobytych danych, aby zapewnić ich dokładność i kompletność.
• Zarządzanie błędami: Zaimplementuj obsługę błędów, aby zarządzać przypadkami, w których ekstrakcja lub parsowanie tekstu kończy się niepowodzeniem, na przykład umieszczając swój kod w bloku try-catch.
• Optymalizacja wydajności: W przypadku dużych plików PDF rozważ optymalizację ekstrakcji tekstu i parsowania, aby zaradzić problemom z wydajnością.

Licencjonowanie IronPDF

IronPDF oferuje różne opcje licencjonowania, pozwalając Ci samodzielnie wypróbować wszystkie potężne funkcje IronPDF przed zobowiązaniem się do zakupu licencji.

Wnioski

Wydobywanie tabel z plików PDF za pomocą IronPDF jest potężnym sposobem na automatyzację ekstrakcji danych, ułatwianie analizy i konwersję dokumentów do bardziej dostępnych formatów. Niezależnie od pracy z prostymi tabelami czy skomplikowanymi, nieregularnymi formatami, IronPDF zapewnia narzędzia potrzebne do skutecznego wydobywania i przetwarzania danych tabelarycznych.

Dzięki IronPDF możesz usprawnić przepływy pracy, takie jak automatyzacja wprowadzania danych, konwersja dokumentów i analiza danych. Elastyczność i zaawansowane funkcje oferowane przez IronPDF czynią go wartościowym narzędziem do obsługi różnych zadań związanych z plikami PDF.