Merge pull request #240 from JimBobSquarePants/tocsoft/DrawText

Move Font to IPath logic to external library

src/ImageSharp.Drawing/ImageSharp.Drawing.csproj

@@ -36,11 +36,10 @@
     <ProjectReference Include="..\ImageSharp\ImageSharp.csproj" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="SixLabors.Shapes.Text" Version="0.1.0-alpha0017" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.0-beta001">
       <PrivateAssets>All</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="SixLabors.Fonts" Version="0.1.0-alpha0010" />
-    <PackageReference Include="SixLabors.Shapes" Version="0.1.0-alpha0012" />
   </ItemGroup>
   <PropertyGroup>
     <CodeAnalysisRuleSet>..\..\ImageSharp.ruleset</CodeAnalysisRuleSet>

src/ImageSharp.Drawing/Paths/DrawPathCollection.cs

@@ -0,0 +1,115 @@
+// <copyright file="DrawPath.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp
+{
+    using Drawing;
+    using Drawing.Brushes;
+    using Drawing.Pens;
+    using ImageSharp.PixelFormats;
+    using SixLabors.Shapes;
+
+    /// <summary>
+    /// Extension methods for the <see cref="Image{TPixel}"/> type.
+    /// </summary>
+    public static partial class ImageExtensions
+    {
+        /// <summary>
+        /// Draws the outline of the polygon with the provided pen.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="pen">The pen.</param>
+        /// <param name="paths">The paths.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Draw<TPixel>(this Image<TPixel> source, IPen<TPixel> pen, IPathCollection paths, GraphicsOptions options)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            foreach (IPath path in paths)
+            {
+                source.Draw(pen, path, options);
+            }
+
+            return source;
+        }
+
+        /// <summary>
+        /// Draws the outline of the polygon with the provided pen.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="pen">The pen.</param>
+        /// <param name="paths">The paths.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Draw<TPixel>(this Image<TPixel> source, IPen<TPixel> pen, IPathCollection paths)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Draw(pen, paths, GraphicsOptions.Default);
+        }
+
+        /// <summary>
+        /// Draws the outline of the polygon with the provided brush at the provided thickness.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="thickness">The thickness.</param>
+        /// <param name="paths">The shapes.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Draw<TPixel>(this Image<TPixel> source, IBrush<TPixel> brush, float thickness, IPathCollection paths, GraphicsOptions options)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Draw(new Pen<TPixel>(brush, thickness), paths, options);
+        }
+
+        /// <summary>
+        /// Draws the outline of the polygon with the provided brush at the provided thickness.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="thickness">The thickness.</param>
+        /// <param name="paths">The paths.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Draw<TPixel>(this Image<TPixel> source, IBrush<TPixel> brush, float thickness, IPathCollection paths)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Draw(new Pen<TPixel>(brush, thickness), paths);
+        }
+
+        /// <summary>
+        /// Draws the outline of the polygon with the provided brush at the provided thickness.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="color">The color.</param>
+        /// <param name="thickness">The thickness.</param>
+        /// <param name="paths">The paths.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Draw<TPixel>(this Image<TPixel> source, TPixel color, float thickness, IPathCollection paths, GraphicsOptions options)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Draw(new SolidBrush<TPixel>(color), thickness, paths, options);
+        }
+
+        /// <summary>
+        /// Draws the outline of the polygon with the provided brush at the provided thickness.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="color">The color.</param>
+        /// <param name="thickness">The thickness.</param>
+        /// <param name="paths">The paths.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Draw<TPixel>(this Image<TPixel> source, TPixel color, float thickness, IPathCollection paths)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Draw(new SolidBrush<TPixel>(color), thickness, paths);
+        }
+    }
+}

src/ImageSharp.Drawing/Paths/FillPathCollection.cs

@@ -0,0 +1,81 @@
+// <copyright file="FillPaths.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp
+{
+    using Drawing;
+    using Drawing.Brushes;
+    using ImageSharp.PixelFormats;
+    using SixLabors.Shapes;
+
+    /// <summary>
+    /// Extension methods for the <see cref="Image{TPixel}"/> type.
+    /// </summary>
+    public static partial class ImageExtensions
+    {
+        /// <summary>
+        /// Flood fills the image in the shape of the provided polygon with the specified brush..
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="paths">The shapes.</param>
+        /// <param name="options">The graphics options.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Fill<TPixel>(this Image<TPixel> source, IBrush<TPixel> brush, IPathCollection paths, GraphicsOptions options)
+          where TPixel : struct, IPixel<TPixel>
+        {
+            foreach (IPath s in paths)
+            {
+                source.Fill(brush, s, options);
+            }
+
+            return source;
+        }
+
+        /// <summary>
+        /// Flood fills the image in the shape of the provided polygon with the specified brush.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="paths">The paths.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Fill<TPixel>(this Image<TPixel> source, IBrush<TPixel> brush, IPathCollection paths)
+          where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Fill(brush, paths, GraphicsOptions.Default);
+        }
+
+        /// <summary>
+        /// Flood fills the image in the shape of the provided polygon with the specified brush..
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="color">The color.</param>
+        /// <param name="paths">The paths.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Fill<TPixel>(this Image<TPixel> source, TPixel color, IPathCollection paths, GraphicsOptions options)
+          where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Fill(new SolidBrush<TPixel>(color), paths, options);
+        }
+
+        /// <summary>
+        /// Flood fills the image in the shape of the provided polygon with the specified brush..
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="color">The color.</param>
+        /// <param name="paths">The paths.</param>
+        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
+        public static Image<TPixel> Fill<TPixel>(this Image<TPixel> source, TPixel color, IPathCollection paths)
+          where TPixel : struct, IPixel<TPixel>
+        {
+            return source.Fill(new SolidBrush<TPixel>(color), paths);
+        }
+    }
+}

src/ImageSharp.Drawing/Text/DrawText.Path.cs

@@ -0,0 +1,200 @@
+// <copyright file="DrawText.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp
+{
+    using System.Numerics;
+
+    using Drawing;
+    using Drawing.Brushes;
+    using Drawing.Pens;
+    using ImageSharp.PixelFormats;
+    using SixLabors.Fonts;
+    using SixLabors.Shapes;
+
+    /// <summary>
+    /// Extension methods for the <see cref="Image{TPixel}"/> type.
+    /// </summary>
+    public static partial class ImageExtensions
+    {
+        /// <summary>
+        /// Draws the text onto the the image filled via the brush.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="color">The color.</param>
+        /// <param name="path">The path.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, TPixel color, IPath path)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.DrawText(text, font, color, path, TextGraphicsOptions.Default);
+        }
+
+        /// <summary>
+        /// Draws the text onto the the image filled via the brush.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="color">The color.</param>
+        /// <param name="path">The path.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, TPixel color, IPath path, TextGraphicsOptions options)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.DrawText(text, font, Brushes.Solid(color), null, path, options);
+        }
+
+        /// <summary>
+        /// Draws the text onto the the image filled via the brush.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="path">The location.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPath path)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.DrawText(text, font, brush, path, TextGraphicsOptions.Default);
+        }
+
+        /// <summary>
+        /// Draws the text onto the the image filled via the brush.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="path">The path.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPath path, TextGraphicsOptions options)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.DrawText(text, font, brush, null, path, options);
+        }
+
+        /// <summary>
+        /// Draws the text onto the the image outlined via the pen.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="pen">The pen.</param>
+        /// <param name="path">The path.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, IPen<TPixel> pen, IPath path)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.DrawText(text, font, pen, path, TextGraphicsOptions.Default);
+        }
+
+        /// <summary>
+        /// Draws the text onto the the image outlined via the pen.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="pen">The pen.</param>
+        /// <param name="path">The path.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, IPen<TPixel> pen, IPath path, TextGraphicsOptions options)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.DrawText(text, font, null, pen, path, options);
+        }
+
+        /// <summary>
+        /// Draws the text onto the the image filled via the brush then outlined via the pen.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="pen">The pen.</param>
+        /// <param name="path">The path.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, IPath path)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            return source.DrawText(text, font, brush, pen, path, TextGraphicsOptions.Default);
+        }
+
+        /// <summary>
+        /// Draws the text onto the the image filled via the brush then outlined via the pen.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of the color.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="text">The text.</param>
+        /// <param name="font">The font.</param>
+        /// <param name="brush">The brush.</param>
+        /// <param name="pen">The pen.</param>
+        /// <param name="path">The path.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>
+        /// The <see cref="Image{TPixel}" />.
+        /// </returns>
+        public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, IPath path, TextGraphicsOptions options)
+           where TPixel : struct, IPixel<TPixel>
+        {
+            Vector2 dpi = DefaultTextDpi;
+            if (options.UseImageResolution)
+            {
+                dpi = new Vector2((float)source.MetaData.HorizontalResolution, (float)source.MetaData.VerticalResolution);
+            }
+
+            var style = new FontSpan(font, dpi)
+            {
+                ApplyKerning = options.ApplyKerning,
+                TabWidth = options.TabWidth,
+                WrappingWidth = options.WrapTextWidth,
+                HorizontalAlignment = options.HorizontalAlignment,
+                VerticalAlignment = options.VerticalAlignment
+            };
+
+            IPathCollection glyphs = TextBuilder.GenerateGlyphs(text, path, style);
+
+            var pathOptions = (GraphicsOptions)options;
+            if (brush != null)
+            {
+                source.Fill(brush, glyphs, pathOptions);
+            }
+
+            if (pen != null)
+            {
+                source.Draw(pen, glyphs, pathOptions);
+            }
+
+            return source;
+        }
+    }
+}

src/ImageSharp.Drawing/Text/DrawText.cs

@@ -12,6 +12,7 @@ namespace ImageSharp
     using Drawing.Pens;
     using ImageSharp.PixelFormats;
     using SixLabors.Fonts;
+    using SixLabors.Shapes;
 
     /// <summary>
     /// Extension methods for the <see cref="Image{TPixel}"/> type.
@@ -167,43 +168,32 @@ namespace ImageSharp
         public static Image<TPixel> DrawText<TPixel>(this Image<TPixel> source, string text, Font font, IBrush<TPixel> brush, IPen<TPixel> pen, Vector2 location, TextGraphicsOptions options)
            where TPixel : struct, IPixel<TPixel>
         {
-            GlyphBuilder glyphBuilder = new GlyphBuilder(location);
-
-            TextRenderer renderer = new TextRenderer(glyphBuilder);
-
             Vector2 dpi = DefaultTextDpi;
             if (options.UseImageResolution)
             {
                 dpi = new Vector2((float)source.MetaData.HorizontalResolution, (float)source.MetaData.VerticalResolution);
             }
 
-            FontSpan style = new FontSpan(font, dpi)
+            var style = new FontSpan(font, dpi)
             {
                 ApplyKerning = options.ApplyKerning,
                 TabWidth = options.TabWidth,
                 WrappingWidth = options.WrapTextWidth,
-                Alignment = options.TextAlignment
+                HorizontalAlignment = options.HorizontalAlignment,
+                VerticalAlignment = options.VerticalAlignment
             };
 
-            renderer.RenderText(text, style);
+            IPathCollection glyphs = TextBuilder.GenerateGlyphs(text, location, style);
-
-            System.Collections.Generic.IEnumerable<SixLabors.Shapes.IPath> shapesToDraw = glyphBuilder.Paths;
 
-            GraphicsOptions pathOptions = (GraphicsOptions)options;
+            var pathOptions = (GraphicsOptions)options;
             if (brush != null)
             {
-                foreach (SixLabors.Shapes.IPath s in shapesToDraw)
+                source.Fill(brush, glyphs, pathOptions);
-                {
-                    source.Fill(brush, s, pathOptions);
-                }
             }
 
             if (pen != null)
             {
-                foreach (SixLabors.Shapes.IPath s in shapesToDraw)
+                source.Draw(pen, glyphs, pathOptions);
-                {
-                    source.Draw(pen, s, pathOptions);
-                }
             }
 
             return source;

src/ImageSharp.Drawing/Text/GlyphBuilder.cs

@@ -1,127 +0,0 @@
-// <copyright file="GlyphBuilder.cs" company="James Jackson-South">
-// Copyright (c) James Jackson-South and contributors.
-// Licensed under the Apache License, Version 2.0.
-// </copyright>
-
-namespace ImageSharp.Drawing
-{
-    using System.Collections.Generic;
-    using System.Numerics;
-
-    using SixLabors.Fonts;
-    using SixLabors.Shapes;
-
-    /// <summary>
-    /// rendering surface that Fonts can use to generate Shapes.
-    /// </summary>
-    internal class GlyphBuilder : IGlyphRenderer
-    {
-        private readonly PathBuilder builder = new PathBuilder();
-        private readonly List<IPath> paths = new List<IPath>();
-        private Vector2 currentPoint = default(Vector2);
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="GlyphBuilder"/> class.
-        /// </summary>
-        public GlyphBuilder()
-            : this(Vector2.Zero)
-        {
-            // glyphs are renderd realative to bottom left so invert the Y axis to allow it to render on top left origin surface
-            this.builder = new PathBuilder();
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="GlyphBuilder"/> class.
-        /// </summary>
-        /// <param name="origin">The origin.</param>
-        public GlyphBuilder(Vector2 origin)
-        {
-            this.builder = new PathBuilder();
-            this.builder.SetOrigin(origin);
-        }
-
-        /// <summary>
-        /// Gets the paths that have been rendered by this.
-        /// </summary>
-        public IEnumerable<IPath> Paths => this.paths;
-
-        /// <summary>
-        /// Begins the glyph.
-        /// </summary>
-        /// <param name="location">The offset that the glyph will be rendered at.</param>
-        void IGlyphRenderer.BeginGlyph(Vector2 location)
-        {
-            this.builder.Clear();
-        }
-
-        /// <summary>
-        /// Begins the figure.
-        /// </summary>
-        void IGlyphRenderer.BeginFigure()
-        {
-            this.builder.StartFigure();
-        }
-
-        /// <summary>
-        /// Draws a cubic bezier from the current point  to the <paramref name="point"/>
-        /// </summary>
-        /// <param name="secondControlPoint">The second control point.</param>
-        /// <param name="thirdControlPoint">The third control point.</param>
-        /// <param name="point">The point.</param>
-        void IGlyphRenderer.CubicBezierTo(Vector2 secondControlPoint, Vector2 thirdControlPoint, Vector2 point)
-        {
-            this.builder.AddBezier(this.currentPoint, secondControlPoint, thirdControlPoint, point);
-            this.currentPoint = point;
-        }
-
-        /// <summary>
-        /// Ends the glyph.
-        /// </summary>
-        void IGlyphRenderer.EndGlyph()
-        {
-            this.paths.Add(this.builder.Build());
-        }
-
-        /// <summary>
-        /// Ends the figure.
-        /// </summary>
-        void IGlyphRenderer.EndFigure()
-        {
-            this.builder.CloseFigure();
-        }
-
-        /// <summary>
-        /// Draws a line from the current point  to the <paramref name="point"/>.
-        /// </summary>
-        /// <param name="point">The point.</param>
-        void IGlyphRenderer.LineTo(Vector2 point)
-        {
-            this.builder.AddLine(this.currentPoint, point);
-            this.currentPoint = point;
-        }
-
-        /// <summary>
-        /// Moves to current point to the supplied vector.
-        /// </summary>
-        /// <param name="point">The point.</param>
-        void IGlyphRenderer.MoveTo(Vector2 point)
-        {
-            this.builder.StartFigure();
-            this.currentPoint = point;
-        }
-
-        /// <summary>
-        /// Draws a quadratics bezier from the current point  to the <paramref name="point"/>
-        /// </summary>
-        /// <param name="secondControlPoint">The second control point.</param>
-        /// <param name="point">The point.</param>
-        void IGlyphRenderer.QuadraticBezierTo(Vector2 secondControlPoint, Vector2 point)
-        {
-            Vector2 c1 = (((secondControlPoint - this.currentPoint) * 2) / 3) + this.currentPoint;
-            Vector2 c2 = (((secondControlPoint - point) * 2) / 3) + point;
-
-            this.builder.AddBezier(this.currentPoint, c1, c2, point);
-            this.currentPoint = point;
-        }
-    }
-}

src/ImageSharp.Drawing/Text/TextGraphicsOptions.cs

@@ -33,7 +33,8 @@ namespace ImageSharp.Drawing
 
         private float wrapTextWidth;
 
-        private SixLabors.Fonts.TextAlignment? textAlignment;
+        private SixLabors.Fonts.HorizontalAlignment? horizontalAlignment;
+        private SixLabors.Fonts.VerticalAlignment? verticalAlignment;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="TextGraphicsOptions" /> struct.
@@ -45,7 +46,8 @@ namespace ImageSharp.Drawing
             this.tabWidth = 4;
             this.useImageResolution = false;
             this.wrapTextWidth = 0;
-            this.textAlignment = SixLabors.Fonts.TextAlignment.Left;
+            this.horizontalAlignment = HorizontalAlignment.Left;
+            this.verticalAlignment = VerticalAlignment.Top;
 
             this.antialiasSubpixelDepth = 16;
             this.blenderMode = PixelBlenderMode.Normal;
@@ -104,7 +106,12 @@ namespace ImageSharp.Drawing
         /// defined by the location and width, if <see cref="WrapTextWidth"/> equals zero, and thus
         /// wrapping disabled, then the alignment is relative to the drawing location.
         /// </summary>
-        public TextAlignment TextAlignment { get => this.textAlignment ?? TextAlignment.Left; set => this.textAlignment = value; }
+        public HorizontalAlignment HorizontalAlignment { get => this.horizontalAlignment ?? HorizontalAlignment.Left; set => this.horizontalAlignment = value; }
+
+        /// <summary>
+        /// Gets or sets a value indicating how to align the text relative to the rendering space.
+        /// </summary>
+        public VerticalAlignment VerticalAlignment { get => this.verticalAlignment ?? VerticalAlignment.Top; set => this.verticalAlignment = value; }
 
         /// <summary>
         /// Performs an implicit conversion from <see cref="GraphicsOptions"/> to <see cref="TextGraphicsOptions"/>.

tests/ImageSharp.Tests/Drawing/Paths/FillPathCollection.cs

@@ -0,0 +1,131 @@
+
+namespace ImageSharp.Tests.Drawing.Paths
+{
+    using System;
+    using ImageSharp;
+    using ImageSharp.Drawing.Brushes;
+    using Xunit;
+    using ImageSharp.Drawing;
+    using System.Numerics;
+    using SixLabors.Shapes;
+    using ImageSharp.Drawing.Processors;
+    using ImageSharp.PixelFormats;
+
+    public class FillPathCollection : IDisposable
+    {
+        GraphicsOptions noneDefault = new GraphicsOptions();
+        Rgba32 color = Rgba32.HotPink;
+        SolidBrush<Rgba32> brush = Brushes.Solid(Rgba32.HotPink);
+        IPath path1 = new SixLabors.Shapes.Path(new LinearLineSegment(new Vector2[] {
+                    new Vector2(10,10),
+                    new Vector2(20,10),
+                    new Vector2(20,10),
+                    new Vector2(30,10),
+                }));
+        IPath path2 = new SixLabors.Shapes.Path(new LinearLineSegment(new Vector2[] {
+                    new Vector2(10,10),
+                    new Vector2(20,10),
+                    new Vector2(20,10),
+                    new Vector2(30,10),
+                }));
+
+        IPathCollection pathCollection;
+
+        private ProcessorWatchingImage img;
+
+        public FillPathCollection()
+        {
+            this.pathCollection = new PathCollection(path1, path2);
+            this.img = new ProcessorWatchingImage(10, 10);
+        }
+
+        public void Dispose()
+        {
+            img.Dispose();
+        }
+
+        [Fact]
+        public void CorrectlySetsBrushAndPath()
+        {
+            img.Fill(brush, pathCollection);
+
+            Assert.Equal(2, img.ProcessorApplications.Count);
+            for (var i = 0; i < 2; i++)
+            {
+                FillRegionProcessor<Rgba32> processor = Assert.IsType<FillRegionProcessor<Rgba32>>(img.ProcessorApplications[i].processor);
+
+                Assert.Equal(GraphicsOptions.Default, processor.Options);
+
+                ShapeRegion region = Assert.IsType<ShapeRegion>(processor.Region);
+
+                // path is converted to a polygon before filling
+                Polygon polygon = Assert.IsType<Polygon>(region.Shape);
+                LinearLineSegment segments = Assert.IsType<LinearLineSegment>(polygon.LineSegments[0]);
+
+                Assert.Equal(brush, processor.Brush);
+            }
+        }
+
+        [Fact]
+        public void CorrectlySetsBrushPathOptions()
+        {
+            img.Fill(brush, pathCollection, noneDefault);
+
+            Assert.Equal(2, img.ProcessorApplications.Count);
+            for (var i = 0; i < 2; i++)
+            {
+                FillRegionProcessor<Rgba32> processor = Assert.IsType<FillRegionProcessor<Rgba32>>(img.ProcessorApplications[i].processor);
+
+                Assert.Equal(noneDefault, processor.Options);
+
+                ShapeRegion region = Assert.IsType<ShapeRegion>(processor.Region);
+                Polygon polygon = Assert.IsType<Polygon>(region.Shape);
+                LinearLineSegment segments = Assert.IsType<LinearLineSegment>(polygon.LineSegments[0]);
+
+                Assert.Equal(brush, processor.Brush);
+            }
+        }
+
+        [Fact]
+        public void CorrectlySetsColorAndPath()
+        {
+            img.Fill(color, pathCollection);
+
+            Assert.Equal(2, img.ProcessorApplications.Count);
+            for (var i = 0; i < 2; i++)
+            {
+                FillRegionProcessor<Rgba32> processor = Assert.IsType<FillRegionProcessor<Rgba32>>(img.ProcessorApplications[i].processor);
+
+                Assert.Equal(GraphicsOptions.Default, processor.Options);
+
+                ShapeRegion region = Assert.IsType<ShapeRegion>(processor.Region);
+                Polygon polygon = Assert.IsType<Polygon>(region.Shape);
+                LinearLineSegment segments = Assert.IsType<LinearLineSegment>(polygon.LineSegments[0]);
+
+                SolidBrush<Rgba32> brush = Assert.IsType<SolidBrush<Rgba32>>(processor.Brush);
+                Assert.Equal(color, brush.Color);
+            }
+        }
+
+        [Fact]
+        public void CorrectlySetsColorPathAndOptions()
+        {
+            img.Fill(color, pathCollection, noneDefault);
+
+            Assert.Equal(2, img.ProcessorApplications.Count);
+            for (var i = 0; i < 2; i++)
+            {
+                FillRegionProcessor<Rgba32> processor = Assert.IsType<FillRegionProcessor<Rgba32>>(img.ProcessorApplications[i].processor);
+
+                Assert.Equal(noneDefault, processor.Options);
+
+                ShapeRegion region = Assert.IsType<ShapeRegion>(processor.Region);
+                Polygon polygon = Assert.IsType<Polygon>(region.Shape);
+                LinearLineSegment segments = Assert.IsType<LinearLineSegment>(polygon.LineSegments[0]);
+
+                SolidBrush<Rgba32> brush = Assert.IsType<SolidBrush<Rgba32>>(processor.Brush);
+                Assert.Equal(color, brush.Color);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Drawing/Text/DrawText.Path.cs

@@ -0,0 +1,251 @@
+// <copyright file="DrawText.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.Tests.Drawing.Text
+{
+    using System;
+    using System.Numerics;
+
+    using ImageSharp.Drawing;
+    using ImageSharp.Drawing.Brushes;
+    using ImageSharp.Drawing.Pens;
+    using ImageSharp.Drawing.Processors;
+    using ImageSharp.PixelFormats;
+    using ImageSharp.Tests.Drawing.Paths;
+
+    using SixLabors.Fonts;
+    using SixLabors.Shapes;
+
+    using Xunit;
+
+    public class DrawText_Path : IDisposable
+    {
+        Rgba32 color = Rgba32.HotPink;
+
+        SolidBrush<Rgba32> brush = Brushes.Solid(Rgba32.HotPink);
+
+        IPath path = new SixLabors.Shapes.Path(
+            new LinearLineSegment(
+                new Vector2[] { new Vector2(10, 10), new Vector2(20, 10), new Vector2(20, 10), new Vector2(30, 10), }));
+
+        private ProcessorWatchingImage img;
+
+        private readonly FontCollection FontCollection;
+
+        private readonly Font Font;
+
+        public DrawText_Path()
+        {
+            this.FontCollection = new FontCollection();
+            this.Font = this.FontCollection.Install(TestFontUtilities.GetPath("SixLaborsSampleAB.woff"));
+            this.img = new ProcessorWatchingImage(10, 10);
+        }
+
+        public void Dispose()
+        {
+            this.img.Dispose();
+        }
+
+        [Fact]
+        public void FillsForEachACharachterWhenBrushSetAndNotPen()
+        {
+            this.img.DrawText(
+                "123",
+                this.Font,
+                Brushes.Solid(Rgba32.Red),
+                null,
+                path,
+                new TextGraphicsOptions(true));
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void FillsForEachACharachterWhenBrushSetAndNotPenDefaultOptions()
+        {
+            this.img.DrawText("123", this.Font, Brushes.Solid(Rgba32.Red), null, path);
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void FillsForEachACharachterWhenBrushSet()
+        {
+            this.img.DrawText("123", this.Font, Brushes.Solid(Rgba32.Red), path, new TextGraphicsOptions(true));
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void FillsForEachACharachterWhenBrushSetDefaultOptions()
+        {
+            this.img.DrawText("123", this.Font, Brushes.Solid(Rgba32.Red), path);
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void FillsForEachACharachterWhenColorSet()
+        {
+            this.img.DrawText("123", this.Font, Rgba32.Red, path, new TextGraphicsOptions(true));
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count);
+            FillRegionProcessor<Rgba32> processor =
+                Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+
+            SolidBrush<Rgba32> brush = Assert.IsType<SolidBrush<Rgba32>>(processor.Brush);
+            Assert.Equal(Rgba32.Red, brush.Color);
+        }
+
+        [Fact]
+        public void FillsForEachACharachterWhenColorSetDefaultOptions()
+        {
+            this.img.DrawText("123", this.Font, Rgba32.Red, path);
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count);
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+            FillRegionProcessor<Rgba32> processor =
+                Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+
+            SolidBrush<Rgba32> brush = Assert.IsType<SolidBrush<Rgba32>>(processor.Brush);
+            Assert.Equal(Rgba32.Red, brush.Color);
+        }
+
+        [Fact]
+        public void DrawForEachACharachterWhenPenSetAndNotBrush()
+        {
+            this.img.DrawText(
+                "123",
+                this.Font,
+                null,
+                Pens.Dash(Rgba32.Red, 1),
+                path,
+                new TextGraphicsOptions(true));
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void DrawForEachACharachterWhenPenSetAndNotBrushDefaultOptions()
+        {
+            this.img.DrawText("123", this.Font, null, Pens.Dash(Rgba32.Red, 1), path);
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void DrawForEachACharachterWhenPenSet()
+        {
+            this.img.DrawText("123", this.Font, Pens.Dash(Rgba32.Red, 1), path, new TextGraphicsOptions(true));
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void DrawForEachACharachterWhenPenSetDefaultOptions()
+        {
+            this.img.DrawText("123", this.Font, Pens.Dash(Rgba32.Red, 1), path);
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(3, this.img.ProcessorApplications.Count); // 3 fills where applied
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+        }
+
+        [Fact]
+        public void DrawForEachACharachterWhenPenSetAndFillFroEachWhenBrushSet()
+        {
+            this.img.DrawText(
+                "123",
+                this.Font,
+                Brushes.Solid(Rgba32.Red),
+                Pens.Dash(Rgba32.Red, 1),
+                path,
+                new TextGraphicsOptions(true));
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(6, this.img.ProcessorApplications.Count);
+        }
+
+        [Fact]
+        public void DrawForEachACharachterWhenPenSetAndFillFroEachWhenBrushSetDefaultOptions()
+        {
+            this.img.DrawText("123", this.Font, Brushes.Solid(Rgba32.Red), Pens.Dash(Rgba32.Red, 1), path);
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(6, this.img.ProcessorApplications.Count);
+        }
+
+        [Fact]
+        public void BrushAppliesBeforPen()
+        {
+            this.img.DrawText(
+                "1",
+                this.Font,
+                Brushes.Solid(Rgba32.Red),
+                Pens.Dash(Rgba32.Red, 1),
+                path,
+                new TextGraphicsOptions(true));
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(2, this.img.ProcessorApplications.Count);
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[1].processor);
+        }
+
+        [Fact]
+        public void BrushAppliesBeforPenDefaultOptions()
+        {
+            this.img.DrawText("1", this.Font, Brushes.Solid(Rgba32.Red), Pens.Dash(Rgba32.Red, 1), path);
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(2, this.img.ProcessorApplications.Count);
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+            Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[1].processor);
+        }
+
+        [Fact]
+        public void GlyphHeightChangesBasedOnuseImageResolutionFlag()
+        {
+            this.img.MetaData.VerticalResolution = 1;
+            this.img.MetaData.HorizontalResolution = 1;
+            this.img.DrawText("1", this.Font, Brushes.Solid(Rgba32.Red), path, new TextGraphicsOptions(true) {
+                UseImageResolution = false
+            });
+
+            this.img.DrawText("1", this.Font, Brushes.Solid(Rgba32.Red), path, new TextGraphicsOptions(true)
+            {
+                UseImageResolution = true
+            });
+
+            Assert.NotEmpty(this.img.ProcessorApplications);
+            Assert.Equal(2, this.img.ProcessorApplications.Count);
+            FillRegionProcessor<Rgba32> ownResolution = Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[0].processor);
+            FillRegionProcessor<Rgba32> imgResolution = Assert.IsType<FillRegionProcessor<Rgba32>>(this.img.ProcessorApplications[1].processor);
+
+            ShapeRegion ownRegion = Assert.IsType<ShapeRegion>(ownResolution.Region);
+            ShapeRegion imgRegion = Assert.IsType<ShapeRegion>(imgResolution.Region);
+
+            // magic numbers based on the font used at well known resolutions
+            Assert.Equal(7.44, ownRegion.Shape.Bounds.Height, 2);
+            Assert.Equal(0.1, imgRegion.Shape.Bounds.Height, 2);
+        }
+    }
+}

tests/ImageSharp.Tests/Drawing/Text/GlyphBuilder.cs

@@ -1,68 +0,0 @@
-
-namespace ImageSharp.Tests.Drawing.Text
-{
-    using ImageSharp.Drawing;
-    using SixLabors.Fonts;
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Numerics;
-    using System.Threading.Tasks;
-    using Xunit;
-
-    public class GlyphBuilderTests
-    {
-        [Fact]
-        public void OriginUsed()
-        {
-            // Y axis is inverted as it expects to be drawing for bottom left
-            GlyphBuilder fullBuilder = new GlyphBuilder(new System.Numerics.Vector2(10, 99));
-            IGlyphRenderer builder = fullBuilder;
-
-            builder.BeginGlyph(Vector2.Zero);
-            builder.BeginFigure();
-            builder.MoveTo(new Vector2(0, 0));
-            builder.LineTo(new Vector2(0, 10)); // becomes 0, -10
-
-            builder.CubicBezierTo(
-                new Vector2(15, 15), // control point -  will not be in the final point collection
-                new Vector2(15, 10), // control point -  will not be in the final point collection
-                new Vector2(10, 10));// becomes 10, -10
-
-            builder.QuadraticBezierTo(
-                new Vector2(10, 5), // control point -  will not be in the final point collection
-                new Vector2(10, 0));
-
-            builder.EndFigure();
-            builder.EndGlyph();
-
-            System.Collections.Immutable.ImmutableArray<Vector2> points = fullBuilder.Paths.Single().Flatten().Single().Points;
-
-            Assert.Contains(new Vector2(10, 99), points);
-            Assert.Contains(new Vector2(10, 109), points);
-            Assert.Contains(new Vector2(20, 99), points);
-            Assert.Contains(new Vector2(20, 109), points);
-        }
-
-        [Fact]
-        public void EachGlypeCausesNewPath()
-        {
-            // Y axis is inverted as it expects to be drawing for bottom left
-            GlyphBuilder fullBuilder = new GlyphBuilder();
-            IGlyphRenderer builder = fullBuilder;
-            for (int i = 0; i < 10; i++)
-            {
-                builder.BeginGlyph(Vector2.Zero);
-                builder.BeginFigure();
-                builder.MoveTo(new Vector2(0, 0));
-                builder.LineTo(new Vector2(0, 10)); // becomes 0, -10
-                builder.LineTo(new Vector2(10, 10));// becomes 10, -10
-                builder.LineTo(new Vector2(10, 0));
-                builder.EndFigure();
-                builder.EndGlyph();
-            }
-
-            Assert.Equal(10, fullBuilder.Paths.Count());
-        }
-    }
-}