merging updates

README.md

@@ -42,7 +42,7 @@ New in v0.0.5 - To create documents use the class ```PdfDocumentBuilder```. Thou
 
     byte[] documentBytes = builder.Build();
 
-    File.WriteAllBytes(@"C:\git\newPdf.pdf");
+    File.WriteAllBytes(@"C:\git\newPdf.pdf", documentBytes);
 
 Each font must be registered with the PdfDocumentBuilder prior to use enable pages to share the font resources. Currently only Standard 14 fonts and TrueType fonts (.ttf) are supported.
 

src/UglyToad.PdfPig.Tests/Graphics/Operations/GraphicsStateOperationTests.cs

@@ -6,6 +6,7 @@
     using System.Linq;
     using System.Reflection;
     using PdfPig.Graphics.Operations;
+    using PdfPig.Graphics.Operations.InlineImages;
     using PdfPig.Tokens;
     using Xunit;
 
@@ -41,6 +42,10 @@ public void AllOperationsCanBeWritten()
 
                     operation = (IGraphicsStateOperation)field.GetValue(null);
                 }
+                else if (operationType == typeof(EndInlineImage))
+                {
+                    operation = new EndInlineImage(new List<IToken>(), new List<byte>());
+                }
                 else
                 {
                     var constructor = constructors[0];

src/UglyToad.PdfPig.Tests/IO/InputBytesTests.cs

@@ -64,6 +64,12 @@ public void ArrayAndStreamBehaveTheSame()
 
                 Assert.True(stream.IsAtEnd());
                 Assert.True(array.IsAtEnd());
+
+                stream.Seek(0);
+                array.Seek(0);
+
+                Assert.False(stream.IsAtEnd());
+                Assert.False(array.IsAtEnd());
             }
         }
     }

src/UglyToad.PdfPig.Tests/PublicApiScannerTests.cs

@@ -65,6 +65,8 @@ public void OnlyExposedApiIsPublic()
                 "UglyToad.PdfPig.DocumentLayoutAnalysis.RecursiveXYCut",
                 "UglyToad.PdfPig.DocumentLayoutAnalysis.XYNode",
                 "UglyToad.PdfPig.DocumentLayoutAnalysis.XYLeaf",
+                "UglyToad.PdfPig.DocumentLayoutAnalysis.TextEdgesExtractor",
+                "UglyToad.PdfPig.DocumentLayoutAnalysis.EdgeType",
                 "UglyToad.PdfPig.Exceptions.PdfDocumentEncryptedException",
                 "UglyToad.PdfPig.Exceptions.PdfDocumentFormatException",
                 "UglyToad.PdfPig.Fonts.DescriptorFontFile",
@@ -174,6 +176,7 @@ public void OnlyExposedApiIsPublic()
                 "UglyToad.PdfPig.Tokens.HexToken",
                 "UglyToad.PdfPig.Tokens.IDataToken`1",
                 "UglyToad.PdfPig.Tokens.IndirectReferenceToken",
+                "UglyToad.PdfPig.Tokens.InlineImageDataToken",
                 "UglyToad.PdfPig.Tokens.IToken",
                 "UglyToad.PdfPig.Tokens.NameToken",
                 "UglyToad.PdfPig.Tokens.NullToken",

src/UglyToad.PdfPig/Content/Page.cs

@@ -9,7 +9,7 @@
     using Util;
     using Util.JetBrains.Annotations;
     using XObjects;
-    using UglyToad.PdfPig.Geometry;
+    using Geometry;
 
     /// <summary>
     /// Contains the content and provides access to methods of a single page in the <see cref="PdfDocument"/>.
@@ -30,23 +30,18 @@ public class Page
 
         internal CropBox CropBox { get; }
 
+        internal PageContent Content { get; }
+
         /// <summary>
         /// The rotation of the page in degrees (clockwise). Valid values are 0, 90, 180 and 270.
         /// </summary>
         public PageRotationDegrees Rotation { get; }
 
-        internal PageContent Content { get; }
-
         /// <summary>
         /// The set of <see cref="Letter"/>s drawn by the PDF content.
         /// </summary>
         public IReadOnlyList<Letter> Letters => Content?.Letters ?? new Letter[0];
-
-        /// <summary>
-        /// The set of <see cref="PdfPath"/>s drawn by the PDF content.
-        /// </summary>
-        public IReadOnlyList<PdfPath> Paths => Content?.Paths ?? new List<PdfPath>();
-
+
         /// <summary>
         /// The full text of all characters on the page in the order they are presented in the PDF content.
         /// </summary>
@@ -136,6 +131,11 @@ public class Experimental
             private readonly Page page;
             private readonly AnnotationProvider annotationProvider;
 
+            /// <summary>
+            /// The set of <see cref="PdfPath"/>s drawn by the PDF content.
+            /// </summary>
+            public IReadOnlyList<PdfPath> Paths => page.Content?.Paths ?? new List<PdfPath>();
+
             internal Experimental(Page page, AnnotationProvider annotationProvider)
             {
                 this.page = page;

src/UglyToad.PdfPig/DocumentLayoutAnalysis/RecursiveXYCut.cs

@@ -11,7 +11,7 @@ namespace UglyToad.PdfPig.DocumentLayoutAnalysis
     /// https://en.wikipedia.org/wiki/Recursive_X-Y_cut
     /// <para>See 'Recursive X-Y Cut using Bounding Boxes of Connected Components' by Jaekyu Ha, Robert M.Haralick and Ihsin T. Phillips</para>
     /// </summary>
-    public class RecursiveXYCut
+    public static class RecursiveXYCut
     {
         /// <summary>
         /// Get the blocks.

src/UglyToad.PdfPig/DocumentLayoutAnalysis/TextEdgesExtractor.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using UglyToad.PdfPig.Content;
+using UglyToad.PdfPig.Geometry;
+
+namespace UglyToad.PdfPig.DocumentLayoutAnalysis
+{
+    /// <summary>
+    /// Text edges extractor. Text edges are where words have either their BoundingBox's left, right or mid coordinates aligned on the same vertical line.
+    /// <para>Useful to detect text columns, tables, justified text, lists, etc.</para>
+    /// </summary>
+    public static class TextEdgesExtractor
+    {
+        /// <summary>
+        /// Functions used to define left, middle and right edges.
+        /// </summary>
+        private static readonly Tuple<EdgeType, Func<PdfRectangle, decimal>>[] edgesFuncs = new Tuple<EdgeType, Func<PdfRectangle, decimal>>[]
+        {
+            Tuple.Create<EdgeType, Func<PdfRectangle, decimal>>(EdgeType.Left,   x => Math.Round(x.Left, 0)),                // use BoundingBox's left coordinate
+            Tuple.Create<EdgeType, Func<PdfRectangle, decimal>>(EdgeType.Mid, x => Math.Round(x.Left + x.Width / 2, 0)),     // use BoundingBox's mid coordinate
+            Tuple.Create<EdgeType, Func<PdfRectangle, decimal>>(EdgeType.Right,  x => Math.Round(x.Right, 0))                // use BoundingBox's right coordinate
+        };
+
+        /// <summary>
+        /// Get the text edges.
+        /// </summary>
+        /// <param name="pageWords">The words in the page.</param>
+        /// <param name="minimumElements">The minimum number of elements to define a text edge.</param>
+        public static IReadOnlyDictionary<EdgeType, List<PdfLine>> GetEdges(IEnumerable<Word> pageWords, int minimumElements = 4)
+        {
+            if (minimumElements < 0)
+            {
+                throw new ArgumentException("TextEdgesExtractor.GetEdges(): The minimum number of elements should be positive.", "minimumElements");
+            }
+
+            var cleanWords = pageWords.Where(x => !string.IsNullOrWhiteSpace(x.Text.Trim()));
+
+            ConcurrentDictionary<EdgeType, List<PdfLine>> dictionary = new ConcurrentDictionary<EdgeType, List<PdfLine>>();
+
+            Parallel.ForEach(edgesFuncs, f =>
+            {
+                dictionary.TryAdd(f.Item1, GetVerticalEdges(cleanWords, f.Item2, minimumElements));
+            });
+            return dictionary.ToDictionary(x => x.Key, x => x.Value);
+        }
+
+        private static List<PdfLine> GetVerticalEdges(IEnumerable<Word> pageWords, Func<PdfRectangle, decimal> func, int minimumElements)
+        {
+            Dictionary<decimal, List<Word>> edges = pageWords.GroupBy(x => func(x.BoundingBox))
+                .Where(x => x.Count() >= minimumElements).ToDictionary(gdc => gdc.Key, gdc => gdc.ToList());
+            Dictionary<decimal, List<List<Word>>> cleanEdges = new Dictionary<decimal, List<List<Word>>>();
+
+            foreach (var edge in edges)
+            {
+                var sortedEdges = edge.Value.OrderBy(x => x.BoundingBox.Bottom).ToList();
+                cleanEdges.Add(edge.Key, new List<List<Word>>());
+
+                var cuttings = pageWords.Except(edge.Value) // remove selected words
+                    // words that cut the vertical line
+                    .Where(x => x.BoundingBox.Left < edge.Key && x.BoundingBox.Right > edge.Key)
+                    // and that are within the boundaries of the edge
+                    .Where(k => k.BoundingBox.Bottom > edge.Value.Min(z => z.BoundingBox.Bottom)
+                        && k.BoundingBox.Top < edge.Value.Max(z => z.BoundingBox.Top))
+                    .OrderBy(x => x.BoundingBox.Bottom).ToList();
+
+                if (cuttings.Count > 0)
+                {
+                    foreach (var cut in cuttings)
+                    {
+                        var group1 = sortedEdges.Where(x => x.BoundingBox.Top < cut.BoundingBox.Bottom).ToList();
+                        if (group1.Count >= minimumElements) cleanEdges[edge.Key].Add(group1);
+                        sortedEdges = sortedEdges.Except(group1).ToList();
+                    }
+                    if (sortedEdges.Count >= minimumElements) cleanEdges[edge.Key].Add(sortedEdges);
+                }
+                else
+                {
+                    cleanEdges[edge.Key].Add(sortedEdges);
+                }
+            }
+
+            return cleanEdges.SelectMany(x => x.Value.Select(y => new PdfLine(x.Key, y.Min(w => w.BoundingBox.Bottom), x.Key, y.Max(w => w.BoundingBox.Top)))).ToList();
+        }
+    }
+
+    /// <summary>
+    /// The type of text edge.
+    /// </summary>
+    public enum EdgeType
+    {
+        /// <summary>
+        /// Text edges where words have their BoundingBox's left coordinate aligned on the same vertical line.
+        /// </summary>
+        Left = 0,
+
+        /// <summary>
+        /// Text edges where words have their BoundingBox's mid coordinate aligned on the same vertical line.
+        /// </summary>
+        Mid = 1,
+
+        /// <summary>
+        /// Text edges where words have their BoundingBox's right coordinate aligned on the same vertical line.
+        /// </summary>
+        Right = 2
+    }
+}

src/UglyToad.PdfPig/Fonts/CidFonts/Type2CidFont.cs

@@ -48,6 +48,11 @@ public Type2CidFont(NameToken type, NameToken subType, NameToken baseFont, Chara
 
         public decimal GetWidthFromFont(int characterIdentifier)
         {
+            if (fontProgram == null)
+            {
+                return GetWidthFromDictionary(characterIdentifier);
+            }
+
             if (fontProgram.TryGetBoundingAdvancedWidth(characterIdentifier, cidToGid.GetGlyphIndex, out var width))
             {
                 return width;