using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var words = page.GetWords(NearestNeighbourWordExtractor.Instance);

		foreach (var word in words)
		{
			// Do something
		}
	}
}

using UglyToad.PdfPig;
using UglyToad.PdfPig.DocumentLayoutAnalysis.WordExtractor;

using (var document = PdfDocument.Open(@"document.pdf"))
{
	string[] punctuation = new[] { ".", "," };
	string[] cannotStartWord = new[] { ")", "]", "!", "?", ";", ":" };
	string[] cannotEndWord = new[] { "(", "[" };

	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var nnOptions = new NearestNeighbourWordExtractor.NearestNeighbourWordExtractorOptions()
		{
			// Ignore the letters that are space or belong to 'punctuation' array
			// These letters will be put in a single word
			FilterPivot = letter => !string.IsNullOrWhiteSpace(letter.Value) &&
				!punctuation.Contains(letter.Value),

			Filter = (pivot, candidate) =>
			{
				if (string.IsNullOrWhiteSpace(candidate.Value) ||
					cannotEndWord.Contains(candidate.Value))
				{
					// start new word if the candidate neighbour is 
					// a space or belongs to 'cannotEndWord' array
					return false;
				}
				else if (cannotStartWord.Contains(pivot.Value))
				{
					// end word if pivot belongs to 'cannotStartWord' array
					return false;
				}
				return true;
			}
		};

		var nnWordExtracor = new NearestNeighbourWordExtractor(nnOptions);

		var words = nnWordExtracor.GetWords(page.Letters);

		foreach (var word in words)
		{
			// Do something
		}
	}
}

 static void testAdv()
 {
     var sb = new StringBuilder();
     string pdfFilePath = @"...\2302.14502.pdf";

     using (var document = UglyToad.PdfPig.PdfDocument.Open(pdfFilePath))
     {
         foreach (var page in document.GetPages())
         {
             // 0. Preprocessing
             var letters = page.Letters; // no preprocessing

             // 1. Extract words
             //var wordExtractor = NearestNeighbourWordExtractor.Instance;
             
             var wordExtractorOptions = new NearestNeighbourWordExtractor.NearestNeighbourWordExtractorOptions()
             {
                 Filter = (pivot, candidate) =>
                 {
                     // check if white space (default implementation of 'Filter')
                     if (string.IsNullOrWhiteSpace(candidate.Value))
                     {
                         // pivot and candidate letters cannot belong to the same word 
                         // if candidate letter is null or white space.
                         // ('FilterPivot' already checks if the pivot is null or white space by default)
                         return false;
                     }

                     // check for height difference
                     var maxHeight = Math.Max(pivot.PointSize, candidate.PointSize);
                     var minHeight = Math.Min(pivot.PointSize, candidate.PointSize);
                     if (minHeight != 0 && maxHeight / minHeight > 2.0)
                     {
                         // pivot and candidate letters cannot belong to the same word 
                         // if one letter is more than twice the size of the other.
                         return false;
                     }

                     // check for colour difference
                     var pivotRgb = pivot.Color.ToRGBValues();
                     var candidateRgb = candidate.Color.ToRGBValues();
                     if (!pivotRgb.Equals(candidateRgb))
                     {
                         // pivot and candidate letters cannot belong to the same word 
                         // if they don't have the same colour.
                         return false;
                     }

                     return true;
                 }
             };

             var wordExtractor = new NearestNeighbourWordExtractor(wordExtractorOptions);

             var words = wordExtractor.GetWords(letters);

             // 2. Segment page
             //var pageSegmenter = DocstrumBoundingBoxes.Instance;
             var pageSegmenterOptions = new DocstrumBoundingBoxes.DocstrumBoundingBoxesOptions()
             {

             };

             var pageSegmenter = new DocstrumBoundingBoxes(pageSegmenterOptions);

             var textBlocks = pageSegmenter.GetBlocks(words);

             // 3. Postprocessing
             var readingOrder = UnsupervisedReadingOrderDetector.Instance;
             var orderedTextBlocks = readingOrder.Get(textBlocks);

             // 4. Extract text
             foreach (var block in orderedTextBlocks)
             {
                 sb.Append(block.Text.Normalize(NormalizationForm.FormKC)); // normalise text
                 sb.AppendLine();
             }

             sb.AppendLine();
         }
     }

     Console.WriteLine(sb.ToString());
 }

var blocks = DefaultPageSegmenter.Instance.GetBlocks(words);

using (var document = PdfDocument.Open(“document.pdf”))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);
		var words = page.GetWords();
		
		// Use default parameters
		// - mode of letters' height and width used as gap size
		// - no minimum block width 
		var blocks = RecursiveXYCut.Instance.GetBlocks(words);

		foreach (var block in blocks)
		{
			// Do something
                        // E.g. Output the blocks
		        foreach (TextLine line in block.TextLines)
		        {
			      foreach (Word word in line.Words)
			      {
				   Console.Write(word.Text + " ");
			      }
		        }

		}
	}
}

var recursiveXYCut = new RecursiveXYCut(new RecursiveXYCut.RecursiveXYCutOptions()
{
    MinimumWidth = page.Width / 3.0
});

var blocks = recursiveXYCut.GetBlocks(words);

var recursiveXYCut = new RecursiveXYCut(new RecursiveXYCut.RecursiveXYCutOptions()
{
    MinimumWidth = page.Width / 3.0,
    DominantFontWidthFunc = _ => page.Letters.Average(l => l.GlyphRectangle.Width),
    DominantFontHeightFunc = _ => page.Letters.Average(l => l.GlyphRectangle.Height)
});

var blocks = recursiveXYCut.GetBlocks(words);

var recursiveXYCut = new RecursiveXYCut(new RecursiveXYCut.RecursiveXYCutOptions()
{
    MinimumWidth = page.Width / 3.0,
    DominantFontWidthFunc = letters => letters.Select(l => l.GlyphRectangle.Width).Average(),
    DominantFontHeightFunc = letters => letters.Select(l => l.GlyphRectangle.Height).Average()
});

var blocks = recursiveXYCut.GetBlocks(words);

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);
		var words = page.GetWords();

		// Use default parameters
		// - within line angle is set to [-30, +30] degree (horizontal angle)
		// - between lines angle is set to [45, 135] degree (vertical angle)
		// - between line multiplier is 1.3
		var blocks = DocstrumBoundingBoxes.Instance.GetBlocks(words);

		foreach (var block in blocks)
		{
			// Do something
		}
	}
}

var docstrum = new DocstrumBoundingBoxes(new DocstrumBoundingBoxes.DocstrumBoundingBoxesOptions()
{
    WithinLineBounds = new DocstrumBoundingBoxes.AngleBounds(-45, 45),
    BetweenLineBounds = new DocstrumBoundingBoxes.AngleBounds(35, 170),
    BetweenLineMultiplier = 1.5
});
docstrum.GetBlocks(words);

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var words = page.GetWords(NearestNeighbourWordExtractor.Instance);
		var blocks = DocstrumBoundingBoxes.Instance.GetBlocks(words);
		var orderedBlocks = DefaultReadingOrderDetector.Instance.Get(blocks);

		foreach (var block in orderedBlocks)
		{
			// Do something
		}
	}
}

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var words = page.GetWords(NearestNeighbourWordExtractor.Instance);
		var blocks = DocstrumBoundingBoxes.Instance.GetBlocks(words);
		var orderedBlocks = RenderingReadingOrderDetector.Instance.Get(blocks);

		foreach (var block in orderedBlocks)
		{
			// Do something
		}
	}
}

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var words = page.GetWords(NearestNeighbourWordExtractor.Instance);
		var blocks = DocstrumBoundingBoxes.Instance.GetBlocks(words);
		var orderedBlocks = UnsupervisedReadingOrderDetector.Instance.Get(blocks);

		foreach (var block in orderedBlocks)
		{
			// Do something
		}
	}
}

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var words = page.GetWords(NearestNeighbourWordExtractor.Instance);
		var blocks = DocstrumBoundingBoxes.Instance.GetBlocks(words);

		var unsupervisedReadingOrderDetector = new UnsupervisedReadingOrderDetector(10);
		var orderedBlocks = unsupervisedReadingOrderDetector.Get(blocks);

		foreach (var block in orderedBlocks)
		{
			// Do something
		}
	}
}

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		// Use default parameters
		// - maximum number of whitespace rectangles is 40 by default
		// - whitespace fuzziness is 0.15
		// - no limit to queue size
		var whitespaces = WhitespaceCoverExtractor.GetWhitespaces(page.GetWords(),
									  page.GetImages());
	}
}

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var whitespaces = WhitespaceCoverExtractor.GetWhitespaces(page.GetWords(),
									  page.GetImages(), 
									  100,
									  10_000);
	}
}

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		var whitespaces = WhitespaceCoverExtractor.GetWhitespaces(page.GetWords(),
									  page.GetImages(),
									  minWidth: 0,
									  minHeight: 0,
									  maxRectangleCount: 100,
									  whitespaceFuzziness: 0.0,
									  maxBoundQueueSize: 10_000);
	}
}

using (var document = PdfDocument.Open(@"document.pdf"))
{
	var docDecorations = DecorationTextBlockClassifier.Get(document.GetPages().ToList(),
						DefaultWordExtractor.Instance,
						DocstrumBoundingBoxes.Instance);

	for (int i = 0; i < document.NumberOfPages; i++)
	{
		IReadOnlyList<TextBlock> decorations = docDecorations[i];
		// Do something
	}
}

using Fastenshtein;

using (var document = PdfDocument.Open(@"document.pdf"))
{
	var docDecorations = DecorationTextBlockClassifier.Get(document.GetPages().ToList(),
						DefaultWordExtractor.Instance,
						DocstrumBoundingBoxes.Instance,
						(string s1, string s2) => Levenshtein.Distance(s1, s2) / (double)Math.Max(s1.Length, s2.Length));
	// The minimum edit distance should be normalised

	for (int i = 0; i < document.NumberOfPages; i++)
	{
		IReadOnlyList<TextBlock> decorations = docDecorations[i];
		// Do something
	}
}

PageXmlTextExporter pageXmlTextExporter = new PageXmlTextExporter(
	DefaultWordExtractor.Instance,
	RecursiveXYCut.Instance,
	UnsupervisedReadingOrderDetector.Instance);

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		// Convert page to text
		string xml = pageXmlTextExporter.Get(page);

		// Save text to an xml file
		File.WriteAllText("document.pagexml.xml", xml);
	}
}

int width = 595;
int height = 841;
var bitmap = new Bitmap(width, height);
using (Graphics graph = Graphics.FromImage(bitmap))
{
    var imageSize = new Rectangle(0, 0, width, height);
    graph.FillRectangle(Brushes.White, imageSize);
}
bitmap.Save(path + ".tif", ImageFormat.Tiff);

AltoXmlTextExporter altoXmlTextExporter = new AltoXmlTextExporter(
	NearestNeighbourWordExtractor.Instance,
	DocstrumBoundingBoxes.Instance);

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		// Convert page to text
		string xml = altoXmlTextExporter.Get(page);

		// Save text to an xml file
		File.WriteAllText("document.altoxml.xml", xml);
	}
}

HOcrTextExporter hocrTextExporter = new HOcrTextExporter(
	DefaultWordExtractor.Instance,
	DocstrumBoundingBoxes.Instance);

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		// Convert page to text
		string html = hocrTextExporter.Get(page);

		// Save text to an html file
		File.WriteAllText("document.hocr.html", html);
	}
}

HOcrTextExporter hocrTextExporter = new HOcrTextExporter(
	DefaultWordExtractor.Instance,
	DocstrumBoundingBoxes.Instance);

using (var document = PdfDocument.Open(@"document.pdf"))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		// Convert page to text, adding a reference to hocrjs script
		string html = hocrTextExporter.Get(page, useHocrjs: true);

		// Save text to an html file
		File.WriteAllText("document.hocr.html", html);
	}
}

SvgTextExporter exporter = new SvgTextExporter();

var options = new ParsingOptions() { ClipPaths = true }; // true if clipped path are needed
using (var document = PdfDocument.Open(@"document.pdf", options ))
{
	for (var i = 0; i < document.NumberOfPages; i++)
	{
		var page = document.GetPage(i + 1);

		// Convert page to text
		var svg = exporter.Get(page);

		// Save text to an html file
		File.WriteAllText("document.html", svg);
	}
}