Program.cs

using GroupDocs.Parser.Data;
using GroupDocs.Parser.Options;
using GroupDocs.Parser.Templates;

namespace GroupDocs.Parser.PdfTablesExtraction
{
    internal class Program
    {
        static void Main(string[] args)
        {
            ExtractTablesPerParticluarPage();
            ExtractAllTablesFromDocument();
            ExtractTablesWithTemplate();
        }

        /// <summary>
        /// Extracts and displays tables from each page of a PDF document.
        /// </summary>
        /// <remarks>
        /// This method processes a PDF document, extracts all tables from each page,
        /// and analyzes each table for its content by rows and columns.
        /// </remarks>
        static void ExtractTablesPerParticluarPage()
        {
            string sample = "Invoices.pdf";

            Console.WriteLine();
            Console.WriteLine($"Extracting tables from: {sample}");

            using (var parser = new Parser(sample))
            {
                var documentInfo = parser.GetDocumentInfo();
                int pageCount = documentInfo.PageCount;

                Console.WriteLine($"Total pages: {pageCount}");
                Console.WriteLine();
                // extract tables from first page
                var pageIndex = 0;
                var tables = parser.GetTables(pageIndex);

                if (tables != null && tables.Any())
                {
                    int tableNumber = 1;
                    foreach (var table in tables)
                    {
                        Console.WriteLine($"  Table {tableNumber}: {table.RowCount} rows x {table.ColumnCount} columns");
                        ProcessTable(table);
                        tableNumber++;
                    }
                }
            }
        }

        /// <summary>
        /// Extracts and displays table sizes from the entire PDF document at once.
        /// </summary>
        static void ExtractAllTablesFromDocument()
        {
            string sample = "TablesReport.pdf";

            Console.WriteLine();
            Console.WriteLine($"Extracting tables from: {sample}");

            using (var parser = new Parser(sample))
            {
                var tables = parser.GetTables();

                if (tables != null && tables.Any())
                {
                    // Group tables by page index
                    var tablesByPage = tables
                        .GroupBy(table => table.Page.Index)
                        .OrderBy(group => group.Key);

                    foreach (var pageGroup in tablesByPage)
                    {
                        int pageIndex = pageGroup.Key;
                        Console.WriteLine($"Tables in the Page {pageIndex + 1}");
                        Console.WriteLine();

                        int tableNumber = 1;
                        foreach (var table in pageGroup)
                        {
                            Console.WriteLine($"  Table {tableNumber}: {table.RowCount} rows x {table.ColumnCount} columns");
                            ProcessTable(table);
                            tableNumber++;
                        }
                        Console.WriteLine();
                    }
                }
            }
        }

        /// <summary>
        /// Extracts tables from a PDF document using a template definition.
        /// </summary>
        /// <remarks>
        /// This method loads a template from an XML file and uses it to extract tables
        /// from the specified PDF document. The template defines the table structure
        /// including column and row positions for precise extraction.
        /// </remarks>
        static void ExtractTablesWithTemplate()
        {
            string sample = "Scanned-tables.pdf";
            string templateFile = "Scanned-tables.layout.xml";

            Console.WriteLine();
            Console.WriteLine($"Extracting tables from: {sample}");
            Console.WriteLine($"Using template: {templateFile}");
            Console.WriteLine();

            using (var parser = new Parser(sample))
            {
                // Load template from XML file
                Template template = Template.Load(templateFile);

                // Parse document using template
                ParseByTemplateOptions options = new ParseByTemplateOptions(0, true, new OcrOptions(new PagePreviewOptions(288)));
                DocumentData data = parser.ParseByTemplate(template, options);

                // Extract all table fields from the parsed data
                var tableFields = data
                    .Where(field => field?.PageArea is PageTableArea)
                    .ToList();

                // Group tables by page
                var tablesByPage = tableFields
                    .Where(field => field?.PageArea != null)
                    .GroupBy(field => field!.PageArea!.Page.Index)
                    .OrderBy(group => group.Key);

                foreach (var pageGroup in tablesByPage)
                {
                    int pageIndex = pageGroup.Key;
                    Console.WriteLine($"Tables in the Page {pageIndex + 1}");
                    Console.WriteLine();

                    int tableNumber = 1;
                    foreach (var field in pageGroup)
                    {
                        if (field.PageArea is PageTableArea table)
                        {
                            Console.WriteLine($"  Table {tableNumber} (Field: {field.Name}): {table.RowCount} rows x {table.ColumnCount} columns");
                            ProcessTable(table);
                            tableNumber++;
                        }
                    }
                    Console.WriteLine();
                }
            }
        }

        /// <summary>
        /// Outputs the content of each table cell to the console.
        /// </summary>
        /// <param name="table">The table.</param>
        static void ProcessTable(PageTableArea table)
        {
            // Calculate column widths for proper alignment
            int[] columnWidths = Enumerable.Range(0, table.ColumnCount)
                .Select(col => Math.Max(3, Enumerable.Range(0, table.RowCount)
                    .Max(row => table[row, col]?.Text?.Length ?? 0)))
                .ToArray();

            // Display table with borders
            string separator = "+" + string.Join("+", columnWidths.Select(w => new string('-', w + 2))) + "+";

            // Display header row (first row)
            Console.WriteLine("    " + separator);
            Console.Write("    |");
            for (int col = 0; col < table.ColumnCount; col++)
            {
                string cellText = GetCellText(table, 0, col);
                Console.Write($" {cellText.PadRight(columnWidths[col])} |");
            }
            Console.WriteLine();
            Console.WriteLine("    " + separator);

            // Display data rows
            for (int row = 1; row < table.RowCount; row++)
            {
                Console.Write("    |");
                for (int col = 0; col < table.ColumnCount; col++)
                {
                    string cellText = GetCellText(table, row, col);
                    Console.Write($" {cellText.PadRight(columnWidths[col])} |");
                }
                Console.WriteLine();
            }
            Console.WriteLine("    " + separator);
        }

        static string GetCellText(PageTableArea table, int row, int col)
        {
            return table[row, col]?.Text ?? "";
        }
    }
}