Cómo extraer datos de tabla de un archivo PDF en C#

En muchos sectores, los archivos PDF son el formato preferido para compartir documentos estructurados como informes, facturas y tablas de datos. Sin embargo, la extracción de datos de los PDF, especialmente cuando se trata de tablas, puede ser un reto debido a la naturaleza del formato PDF. A diferencia de los formatos de datos estructurados, los PDF están diseñados principalmente para la presentación, no para la extracción de datos.

Sin embargo, con IronPDF, una poderosa biblioteca C# PDF .NET, puedes extraer fácilmente datos estructurados como tablas directamente de los PDF y procesarlos en tus aplicaciones .NET. Este artículo le guiará paso a paso sobre cómo extraer datos tabulares de archivos PDF utilizando IronPDF.

¿Cuándo necesitaría extraer tablas de documentos PDF?

Las tablas son una forma práctica de estructurar y mostrar los datos, ya sea para llevar a cabo la gestión de inventarios, la introducción de datos, el registro de datos como las precipitaciones, etc. Por lo tanto, también puede haber muchas razones para necesitar extraer tablas y datos de tablas de documentos PDF. Algunos de los casos de uso más comunes son:

• Automatización de la entrada de datos: La extracción de datos de tablas en informes PDF o facturas puede automatizar procesos como el llenado de bases de datos u hojas de cálculo.
• Análisis de datos: Las empresas a menudo reciben informes estructurados en formato PDF. La extracción de tablas permite analizar estos datos mediante programación.
• Conversión de documentos: La extracción de datos tabulares en formatos más accesibles como Excel o CSV permite una manipulación, almacenamiento y compartición más sencilla.
• Auditoría y cumplimiento: Para registros legales o financieros, extraer datos tabulares de documentos PDF programáticamente puede ayudar a automatizar auditorías y garantizar el cumplimiento.

¿Cómo funcionan las tablas PDF?

El formato de archivo PDF no ofrece ninguna capacidad nativa para almacenar datos en formatos estructurados como tablas. La tabla que usamos en el ejemplo de hoy fue creada en HTML, antes de ser convertida a formato PDF. Las tablas se renderizan como texto y líneas, por lo que extraer los datos de las tablas a menudo requiere un análisis y la interpretación del contenido, a menos que se esté utilizando software de OCR, como IronOCR.

Cómo extraer datos de tabla de un archivo PDF en C#

Antes de explorar cómo IronPDF puede abordar esta tarea, exploremos primero una herramienta en línea capaz de gestionar la extracción de PDF. Para extraer una tabla de un documento PDF utilizando una herramienta PDF en línea, siga los pasos que se indican a continuación:

1. Ir a la herramienta gratuita de extracción de PDF en línea

2. Cargar el PDF que contiene la tabla

3. Ver y descargar los resultados

Paso uno: Vaya a la herramienta gratuita de extracción de PDF en línea

Hoy, utilizaremos Docsumo como nuestro ejemplo de herramienta PDF en línea. Docsumo es un AI en línea de documentos PDF que ofrece una herramienta gratuita de extracción de tablas PDF.

Segundo paso: cargar el PDF que contiene la tabla

Ahora, haga clic en el botón "Cargar archivo" para cargar su archivo PDF para la extracción. La herramienta comenzará inmediatamente a procesar tu PDF.

Tercer paso: Ver y descargar los resultados

Una vez que Docsumo haya terminado de procesar el PDF, mostrará la tabla extraída. A continuación, puede realizar ajustes en la estructura de la tabla, como añadir y eliminar filas. Aquí puede descargar la tabla en formato PDF, XLS, JSON o texto.

Extraer datos de tablas con IronPDF

IronPDF permite extraer datos, texto y gráficos de PDF, que luego pueden utilizarse para reconstruir tablas mediante programación. Para ello, primero tendrá que extraer el contenido textual de la tabla en el PDF y luego utilizar ese texto para analizar la tabla en filas y columnas. Antes de comenzar a extraer tablas, echemos un vistazo a cómo funciona el método ExtractAllText() de IronPDF extrayendo los datos dentro de una tabla:

using IronPDF;
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
string text = pdf.ExtractAllText();
Console.WriteLine(text);

using IronPDF;
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
string text = pdf.ExtractAllText();
Console.WriteLine(text);

Imports IronPDF
Private pdf As PdfDocument = PdfDocument.FromFile("example.pdf")
Private text As String = pdf.ExtractAllText()
Console.WriteLine(text)

En este ejemplo, hemos cargado el documento PDF utilizando la clase PdfDocument, y luego usamos el método ExtractAllText() para extraer todo el texto dentro del documento, antes de finalmente mostrar el texto en la consola.

Extracción de datos de tabla a partir de texto con IronPDF

Tras extraer el texto del PDF, la tabla aparecerá como una serie de filas y columnas en texto sin formato. Puedes dividir este texto basado en saltos de línea (\n) y luego dividir aún más las filas en columnas basándote en espacios consistentes o delimitadores como comas o tabulaciones. He aquí un ejemplo básico de cómo analizar la tabla a partir del texto:

using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("table.pdf");
string text = pdf.ExtractAllText();
string[] lines = text.Split('\n');
foreach (string line in lines)
{
    string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
    Console.WriteLine("Row: ");
    foreach (string column in columns)
    {
        Console.WriteLine("  " + column);
    }
}

using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("table.pdf");
string text = pdf.ExtractAllText();
string[] lines = text.Split('\n');
foreach (string line in lines)
{
    string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
    Console.WriteLine("Row: ");
    foreach (string column in columns)
    {
        Console.WriteLine("  " + column);
    }
}

Imports Microsoft.VisualBasic
Imports IronPdf
Private pdf As PdfDocument = PdfDocument.FromFile("table.pdf")
Private text As String = pdf.ExtractAllText()
Private lines() As String = text.Split(ControlChars.Lf)
For Each line As String In lines
	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)
	Next column
Next line

En este ejemplo, hemos seguido los mismos pasos que antes para cargar nuestro documento PDF y extraer el texto. Luego, usando text.Split('\n') dividimos el texto extraído en filas basadas en los saltos de línea y almacenamos los resultados en el array lines. A continuación, se utiliza un bucle foreach para recorrer las filas en el array, donde line.Split('\t') se utiliza para dividir aún más las filas en columnas usando el carácter de tabulación '\t' como delimitador. La siguiente parte del array de columnas, Where(col => !string.IsNullOrWhiteSpace(col)).ToArray() filtra las columnas vacías que pueden surgir debido a espacios adicionales, y luego agrega las columnas al array de columnas.

Por último, escribimos texto en la ventana de salida de la consola con estructuración básica de filas y columnas.

Exportación de datos de tabla extraídos a CSV

Ahora que ya sabemos cómo extraer tablas de archivos PDF, veamos qué podemos hacer con los datos extraídos. Exportar la tabla exportada como archivo CSV es una forma útil de manejar los datos de la tabla y automatizar tareas como la introducción de datos. Para este ejemplo, hemos rellenado una tabla con datos simulados, en este caso, la cantidad de lluvia diaria en una semana, hemos extraído la tabla del PDF y, a continuación, la hemos exportado a un archivo CSV.

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);
        var text = pdf.ExtractTextFromPage(0); // Extract text from the first page
        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);
            }
        }
    }
}

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);
        var text = pdf.ExtractTextFromPage(0); // Extract text from the first page
        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

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)
		Dim text = pdf.ExtractTextFromPage(0) ' Extract text from the first page
		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) 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

Ejemplo de archivo PDF

Archivo CSV de salida

Como puedes ver, hemos exportado con éxito la tabla PDF a CSV. En primer lugar, cargamos el PDF que contiene la tabla y creamos una nueva ruta de archivo CSV. Después de esto, extrajimos la tabla usando la línea var tableData = ExtractTableDataFromPdf(pdfPath), que se llama al método ExtractTableDataFromPdf(). Este método extrae todo el texto de la página PDF en la que se encuentra la tabla, almacenándolo en la variable text.

A continuación, dividimos el texto en líneas y columnas. Finalmente, después de devolver el resultado de este proceso de división, llamamos al método static void WriteDataToCsv() que toma el texto extraído y dividido y lo escribe en nuestro archivo CSV usando StreamWriter.

Consejos y buenas prácticas

Cuando se trabaja con tablas PDF, seguir algunas de las mejores prácticas básicas puede ayudar a minimizar la posibilidad de encontrarse con errores o problemas.

• Preprocesar PDFs: Si es posible, preprocese sus PDFs para asegurar un formateo consistente, lo que simplifica el proceso de extracción.
• Validar datos: Siempre valide los datos extraídos para garantizar su precisión y completitud.
• Manejar errores: Implementa el manejo de errores para gestionar los casos en los que la extracción o el análisis de texto fallen, como envolver tu código dentro de un bloque try-catch.
• Optimizar el rendimiento: Para documentos PDF grandes, considere optimizar la extracción y el análisis de texto para manejar problemas de rendimiento.

Licencias IronPDF

IronPDF ofrece diferentes licencias disponibles, permitiéndote probar todas las potentes características que IronPDF tiene para ofrecer por ti mismo antes de comprometerte con una licencia.

Conclusión

Extraer tablas de PDFs usando IronPDF es una forma poderosa de automatizar la extracción de datos, facilitar el análisis y convertir documentos en formatos más accesibles. Tanto si se trata de tablas sencillas como de formatos complejos e irregulares, IronPDF proporciona las herramientas necesarias para extraer y procesar datos de tablas de forma eficiente.

Con IronPDF, puede agilizar flujos de trabajo como la entrada automática de datos, la conversión de documentos y el análisis de datos. La flexibilidad y las funciones avanzadas que ofrece IronPDF lo convierten en una herramienta valiosa para gestionar diversas tareas basadas en PDF.