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, conIronPDFcon C# PDF .NET, una potente biblioteca PDF .NET de C#, puede extraer fácilmente datos estructurados, como tablas, directamente de PDF y procesarlos en sus 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 o facturas en PDF puede automatizar procesos como el relleno de bases de datos u hojas de cálculo.
• Análisis de datos: Las empresas suelen recibir 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 a formatos más accesibles como Excel o CSV permite una manipulación, almacenamiento y uso compartido más sencillos.
• Auditoría y cumplimiento: Para registros legales o financieros, extraer datos tabulares de documentos PDF mediante programación 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 utilizamos en el ejemplo de hoy se creó en HTML, antes de serconvertido a formato PDF. Las tablas se representan como texto y líneas, por lo que la extracción de los datos de las tablas suele requerir cierto análisis e interpretación del contenido, a menos que se utilice un software de reconocimiento óptico de caracteres, como por ejemploIronOCR.

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 empezar a extraer tablas, echemos un vistazo a cómo IronPDF'sExtraerTodoTexto() funciona extrayendo los datos 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 función**Documento PDF y, a continuación, utilizar la función ExtractAllText() método para extraer todo el texto dentro del documento, antes de mostrar finalmente 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. Puede dividir este texto en función de los saltos de línea(\n) y, a continuación, dividir las filas en columnas basándose en un espaciado coherente o en 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. A continuación, utilizando text.Split('\n') Dividimos el texto extraído en filas en función de los saltos de línea y almacenamos los resultados en la matriz líneas. A continuación, se utiliza un bucle foreach para recorrer las filas de la matriz, donde line.Split('\t') Para dividir las filas en columnas se utiliza el carácter de tabulación '\t' como delimitador. La siguiente parte de la matriz de columnas, Dónde(col =>!string.IsNullOrWhiteSpace(col)).ToArray() filtra las columnas vacías que puedan surgir debido a espacios adicionales y, a continuación, añade las columnas a la matriz 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. A continuación, extraemos la tabla utilizando el método var tableData = ExtractTableDataFromPdf(pdfPath), que se denomina ExtractTableDataFromPdf() método. Este método extrae todo el texto de la página PDF en la que se encuentra la tabla y lo almacena en la variable text.

A continuación, dividimos el texto en líneas y columnas. Por último, tras 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 utilizando 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.

• Preprocese los PDF: Si es posible, preprocese sus PDF para garantizar un formato coherente, lo que simplificará el proceso de extracción.
• Validación de datos: Valide siempre los datos extraídos para garantizar su precisión e integridad.
• Manejar errores: Implementar el manejo de errores para gestionar los casos en los que la extracción de texto o el análisis sintáctico fallan, como envolver el código dentro de un bloque try-catch.
• Optimizar el rendimiento: En el caso de PDF de gran tamaño, considere la posibilidad de optimizar la extracción de texto y el análisis sintáctico para gestionar los problemas de rendimiento.

Licencias IronPDF

IronPDF ofrece diferentes productoslicencias está disponible, lo que le permite probar por sí mismo todas las potentes funciones que IronPDF puede ofrecerle antes de comprometerse a adquirir una licencia.

Conclusión

Extracción de tablas de PDF conIronPDF es una forma eficaz de automatizar la extracción de datos, facilitar el análisis y convertir documentos a 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.