Em muitos setores, os arquivos PDF são o formato preferido para compartilhar documentos estruturados, como relatórios, faturas e tabelas de dados. No entanto, extrair dados de PDFs, especialmente quando se trata de tabelas, pode ser um desafio devido à natureza do formato PDF. Ao contrário dos formatos de dados estruturados, os PDFs são projetados principalmente para apresentação, não para extração de dados.
No entanto, com o IronPDF , uma poderosa biblioteca C# para PDF em .NET , você pode facilmente extrair dados estruturados, como tabelas, diretamente de PDFs e processá-los em seus aplicativos .NET . Este artigo irá guiá-lo passo a passo sobre como extrair dados tabulares de arquivos PDF usando o IronPDF.
As tabelas são uma maneira prática de estruturar e exibir seus dados, seja para gerenciamento de estoque, entrada de dados, registro de dados como precipitação, etc. Portanto, pode haver muitos motivos para precisar extrair tabelas e dados de tabelas de documentos PDF. Alguns dos casos de uso mais comuns incluem:
O formato de arquivo PDF não oferece nenhuma capacidade nativa de armazenar dados em formatos estruturados, como tabelas. A tabela que usamos no exemplo de hoje foi criada em HTML, antes de ser convertida para o formato PDF . As tabelas são representadas como texto e linhas, portanto, a extração de dados de tabelas geralmente requer alguma análise e interpretação do conteúdo, a menos que você esteja usando um software de OCR, como o IronOCR .
Antes de explorarmos como o IronPDF pode lidar com essa tarefa, vamos primeiro explorar uma ferramenta online capaz de extrair PDFs. Para extrair uma tabela de um documento PDF usando uma ferramenta online de PDF, siga os passos descritos abaixo:
Hoje, usaremos o Docsumo como exemplo de ferramenta online para criação de PDFs. Docsumo é uma IA online para documentos PDF que oferece uma ferramenta gratuita para extração de tabelas de PDFs.
Agora, clique no botão "Carregar arquivo" para enviar seu arquivo PDF para extração. A ferramenta começará imediatamente a processar seu PDF.
Assim que o Docsumo terminar de processar o PDF, ele exibirá a tabela extraída. Em seguida, você pode fazer ajustes na estrutura da tabela, como adicionar e remover linhas. Aqui, você pode baixar a tabela em formato PDF, XLS, JSON ou texto.
O IronPDF permite extrair dados, texto e gráficos de PDFs, que podem então ser usados para reconstruir tabelas programaticamente. Para isso, primeiro você precisará extrair o conteúdo textual da tabela no PDF e, em seguida, usar esse texto para analisar a tabela em linhas e colunas. Antes de começarmos a extrair tabelas, vamos dar uma olhada em como o método ExtractAllText() do IronPDF funciona, extraindo os dados de uma tabela:
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
Module Program
Sub Main(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 Module
Neste exemplo, carregamos o documento PDF usando a classe PdfDocument e, em seguida, usamos o método ExtractAllText() para extrair todo o texto do documento, antes de finalmente exibi-lo no console.
Após extrair o texto do PDF, a tabela aparecerá como uma série de linhas e colunas em texto simples. Você pode dividir este texto com base em quebras de linha ( \n ) e, em seguida, dividir ainda mais as linhas em colunas com base em espaçamento consistente ou delimitadores, como vírgulas ou tabulações. Aqui está um exemplo básico de como analisar a tabela a partir do texto:
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 IronPDF
Imports System
Imports System.Linq
Module Program
Sub Main(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
Next
End Sub
End Module
Neste exemplo, seguimos os mesmos passos de antes para carregar nosso documento PDF e extrair o texto. Em seguida, usando text.Split('\n'), dividimos o texto extraído em linhas com base nas quebras de linha e armazenamos os resultados na matriz lines . Em seguida, um loop foreach é usado para percorrer as linhas da matriz, onde line.Split('\t') é usado para dividir ainda mais as linhas em colunas usando o caractere de tabulação '\t' como delimitador. A próxima parte da matriz de colunas, Where(col => !string.IsNullOrWhiteSpace(col)).ToArray() filtra colunas vazias que podem surgir devido a espaços extras e, em seguida, adiciona as colunas à matriz de colunas.
Finalmente, escrevemos o texto na janela de saída do console com estrutura básica de linhas e colunas.
Agora que já vimos como extrair tabelas de arquivos PDF, vamos dar uma olhada no que podemos fazer com esses dados extraídos. Exportar a tabela exportada como um arquivo CSV é uma maneira útil de lidar com dados de tabelas e automatizar tarefas como a entrada de dados. Neste exemplo, preenchemos uma tabela com dados simulados, neste caso, a quantidade diária de chuva em uma semana, extraímos a tabela do PDF e, em seguida, exportamos para um arquivo 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);
}
}
}
}Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Linq
Imports IronPdf
Module Program
Sub Main(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
Function ExtractTableDataFromPdf(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(New Char() { " "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
Return rows
End Function
Sub WriteDataToCsv(data As List(Of String()), 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
End Using
End Sub
End Module
Como você pode ver, exportamos com sucesso a tabela do PDF para CSV. Primeiro, carregamos o PDF contendo a tabela e criamos um novo caminho de arquivo CSV. Depois disso, extraímos a tabela usando a linha var tableData = ExtractTableDataFromPdf(pdfPath) , que é chamada de método ExtractTableDataFromPdf() . Este método extrai todo o texto da página do PDF onde a tabela está localizada, armazenando-o na variável de texto .
Em seguida, dividimos o texto em linhas e colunas. Finalmente, após retornar o resultado desse processo de divisão, chamamos o método estático void WriteDataToCsv() que pega o texto extraído e dividido e o escreve em nosso arquivo CSV usando StreamWriter .
Ao trabalhar com tabelas em PDF, seguir algumas boas práticas básicas pode ajudar a minimizar a probabilidade de erros ou problemas.
A IronPDF oferece diferentes opções de licenciamento , permitindo que você experimente todos os recursos poderosos que a IronPDF oferece antes de se comprometer com uma licença.
Extrair tabelas de PDFs usando o IronPDF é uma maneira poderosa de automatizar a extração de dados, facilitar a análise e converter documentos em formatos mais acessíveis. Seja lidando com tabelas simples ou formatos complexos e irregulares, o IronPDF fornece as ferramentas necessárias para extrair e processar dados tabulares de forma eficiente.
Com o IronPDF, você pode otimizar fluxos de trabalho como entrada automatizada de dados, conversão de documentos e análise de dados. A flexibilidade e os recursos avançados oferecidos pelo IronPDF o tornam uma ferramenta valiosa para lidar com diversas tarefas baseadas em PDF.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
