RichTextGlyphRenderer works!

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor.cs

@@ -46,7 +46,7 @@ public DrawTextProcessor(DrawingOptions drawingOptions, TextDrawingOptions textO
         public DrawingOptions DrawingOptions { get; }
 
         /// <summary>
-        /// Gets the <see cref="Processing.TextDrawingOptions"/> defining text-specific drawing settings.
+        /// Gets the <see cref="TextDrawingOptions"/> defining text-specific drawing settings.
         /// </summary>
         public TextDrawingOptions TextOptions { get; }
 

src/ImageSharp.Drawing/Processing/Processors/Text/DrawTextProcessor{TPixel}.cs

@@ -4,9 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using SixLabors.Fonts;
-using SixLabors.Fonts.Unicode;
-using SixLabors.ImageSharp.Drawing.Processing.Processors.Drawing;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors;
@@ -32,43 +31,24 @@ protected override void BeforeImageApply()
         {
             base.BeforeImageApply();
 
-            // Do everything at the image level as we are delegating the processing down to other processors
-            //this.textRenderer = new CachingGlyphRenderer(
-            //    this.Configuration.MemoryAllocator,
-            //    this.definition.Text.GetGraphemeCount(),
-            //    this.definition.TextOptions,
-            //    this.definition.Pen,
-            //    this.definition.Brush,
-            //    this.definition.DrawingOptions.Transform)
-            //{
-            //    Options = this.definition.DrawingOptions
-            //};
+            // Do everything at the image level as we are delegating
+            // the processing down to other processors
+            TextDrawingOptions textOptions = ConfigureOptions(this.definition.TextOptions);
 
             this.textRenderer = new RichTextGlyphRenderer(
-                this.definition.TextOptions,
+                textOptions,
                 this.definition.DrawingOptions,
                 this.Configuration.MemoryAllocator,
                 this.definition.Pen,
                 this.definition.Brush);
 
             TextRenderer renderer = new(this.textRenderer);
-            renderer.RenderText(this.definition.Text, this.definition.TextOptions);
+            renderer.RenderText(this.definition.Text, textOptions);
         }
 
         protected override void AfterImageApply()
         {
             base.AfterImageApply();
-
-            foreach (var path in this.textRenderer.Paths)
-            {
-                new FillPathProcessor(
-                    this.definition.DrawingOptions,
-                    new SolidBrush(Color.HotPink.WithAlpha(.5F)),
-                    path).Execute(this.Configuration, this.Source, this.SourceRectangle);
-            }
-
-
-
             this.textRenderer?.Dispose();
             this.textRenderer = null;
         }
@@ -135,5 +115,20 @@ void Draw(IEnumerable<DrawingOperation> operations)
                 Draw(this.textRenderer.DrawingOperations.OrderBy(x => x.RenderPass));
             }
         }
+
+        private static TextDrawingOptions ConfigureOptions(TextDrawingOptions options)
+        {
+            // When a path is specified we should explicitly follow that path
+            // and not adjust the origin. Any tranlation should be applied to the path.
+            if (options.Path is not null && options.Origin != Vector2.Zero)
+            {
+                return new(options)
+                {
+                    Origin = Vector2.Zero
+                };
+            }
+
+            return options;
+        }
     }
 }

src/ImageSharp.Drawing/Processing/Processors/Text/RichTextGlyphRenderer.cs

@@ -15,16 +15,20 @@
 
 namespace SixLabors.ImageSharp.Drawing.Processing.Processors.Text
 {
-    // TODO: Fix path rendering and add caching.
-    internal sealed class RichTextGlyphRenderer : GlyphBuilder, IColorGlyphRenderer, IDisposable
+    // TODO: Add caching.
+    internal sealed class RichTextGlyphRenderer : BaseGlyphBuilder, IColorGlyphRenderer, IDisposable
     {
+        private const byte RenderOrderFill = 0;
+        private const byte RenderOrderOutline = 1;
+        private const byte RenderOrderDecoration = 2;
+
         private readonly TextDrawingOptions textOptions;
         private readonly DrawingOptions drawingOptions;
         private readonly MemoryAllocator memoryAllocator;
         private readonly Pen defaultPen;
         private readonly Brush defaultBrush;
         private readonly IPathInternals path;
-        private Vector2 textOffset;
+        private Vector2 textPathOffset;
         private bool isDisposed;
 
         private readonly Dictionary<Color, Brush> brushLookup = new();
@@ -35,25 +39,24 @@ internal sealed class RichTextGlyphRenderer : GlyphBuilder, IColorGlyphRenderer,
         private TextDecorationDetails? currentUnderline;
         private TextDecorationDetails? currentStrikout;
         private TextDecorationDetails? currentOverline;
-        private Point currentRenderPosition;
-        private Matrix3x2 currentTransform;
 
         public RichTextGlyphRenderer(
             TextDrawingOptions textOptions,
             DrawingOptions drawingOptions,
             MemoryAllocator memoryAllocator,
             Pen pen,
             Brush brush)
-            : base(textOptions.Origin)
         {
             this.textOptions = textOptions;
             this.drawingOptions = drawingOptions;
-            this.currentTransform = this.drawingOptions.Transform;
             this.memoryAllocator = memoryAllocator;
             this.defaultPen = pen;
             this.defaultBrush = brush;
             this.DrawingOperations = new List<DrawingOperation>();
 
+            // Set the default transform.
+            this.Builder.SetTransform(drawingOptions.Transform);
+
             IPath path = textOptions.Path;
             if (path is not null)
             {
@@ -95,7 +98,7 @@ protected override void BeginText(in FontRectangle bounds)
                 HorizontalAlignment.Left => bounds.Left,
                 _ => bounds.Left,
             };
-            this.textOffset = new(xOffset, yOffset);
+            this.textPathOffset = new(xOffset, yOffset);
         }
 
         /// <inheritdoc/>
@@ -272,21 +275,21 @@ protected override void EndGlyph()
             {
                 this.DrawingOperations.Add(new DrawingOperation
                 {
-                    Location = this.currentRenderPosition,
+                    Location = Point.Truncate(path.Bounds.Location),
                     Map = renderData.FillMap,
                     Brush = this.currentBrush,
-                    RenderPass = 1
+                    RenderPass = RenderOrderFill
                 });
             }
 
             if (renderData.OutlineMap != null)
             {
                 this.DrawingOperations.Add(new DrawingOperation
                 {
-                    Location = this.currentRenderPosition,
+                    Location = Point.Truncate(path.Bounds.Location),
                     Map = renderData.OutlineMap,
                     Brush = this.currentPen?.StrokeFill ?? this.currentBrush,
-                    RenderPass = 2 // Render outlines 2nd to ensure they are always on top of fills
+                    RenderPass = RenderOrderOutline
                 });
             }
         }
@@ -305,13 +308,18 @@ private void FinalizeDecoration(ref TextDecorationDetails? decoration)
         {
             if (decoration != null)
             {
-                // TODO: If the path is curved ths does not work well.
+                // TODO: If the path is curved a line segment does not work well.
                 // What would be great would be if we could take a slice of a path given an offset and length.
                 IPath path = new Path(new LinearLineSegment(decoration.Value.Start, decoration.Value.End));
-                path = path.Transform(this.currentTransform);
-
                 IPath outline = decoration.Value.Pen.GeneratePath(path, decoration.Value.Thickness);
 
+                // Calculate the transform for this path.
+                // We cannot use the pathbuilder transform as this path is rendered independently.
+                FontRectangle rectangle = new(outline.Bounds.Location, new(outline.Bounds.Width, outline.Bounds.Height));
+                Matrix3x2 pathTransform = this.ComputeTransform(in rectangle);
+                Matrix3x2 defaultTransform = this.drawingOptions.Transform;
+                outline = outline.Transform(pathTransform * defaultTransform);
+
                 if (outline.Bounds.Width != 0 && outline.Bounds.Height != 0)
                 {
                     // Render the Path here
@@ -320,7 +328,7 @@ private void FinalizeDecoration(ref TextDecorationDetails? decoration)
                         Brush = decoration.Value.Pen.StrokeFill,
                         Location = Point.Truncate(outline.Bounds.Location),
                         Map = this.Render(outline),
-                        RenderPass = 3 // after outlines !!
+                        RenderPass = RenderOrderDecoration
                     });
                 }
 
@@ -336,15 +344,15 @@ private void AppendDecoration(ref TextDecorationDetails? decoration, Vector2 sta
                 if (this.path is not null)
                 {
                     // Let's try and expand it first.
-                    if (thickness == decoration.Value.Thickness &&
-                        decoration.Value.End.Y == start.Y &&
-                        (decoration.Value.End.X + 1) >= start.X &&
-                        decoration.Value.Pen.Equals(pen))
+                    if (thickness == decoration.Value.Thickness
+                        && decoration.Value.End.Y == start.Y
+                        && (decoration.Value.End.X + 1) >= start.X
+                        && decoration.Value.Pen.Equals(pen))
                     {
                         // Expand the line
                         start = decoration.Value.Start;
 
-                        // If this is null finalize does nothing we then set it again before we leave
+                        // If this is null finalize does nothing.
                         decoration = null;
                     }
                 }
@@ -363,14 +371,22 @@ private void AppendDecoration(ref TextDecorationDetails? decoration, Vector2 sta
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void TransformGlyph(in FontRectangle bounds)
         {
-            // We don't have access to the pathbuilder transform here so we recreate it from the origin.
-            var origin = Matrix3x2.CreateTranslation(this.textOptions.Origin);
             if (this.path is null)
             {
-                this.currentRenderPosition = Point.Truncate(PointF.Transform(bounds.Location, origin));
                 return;
             }
 
+            this.Builder.SetTransform(this.ComputeTransform(in bounds));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private Matrix3x2 ComputeTransform(in FontRectangle bounds)
+        {
+            if (this.path is null)
+            {
+                return Matrix3x2.Identity;
+            }
+
             // Find the intersection point.
             // This should be offset to ensure we rotate at the bottom-center of the glyph.
             float halfWidth = bounds.Width * .5F;
@@ -383,18 +399,11 @@ private void TransformGlyph(in FontRectangle bounds)
             // characters in multiline text scales with the angle and vertical offset.
             // This is expected and consistant with other libraries.
             // Multiple line text should be rendered using multiple paths to avoid this behavior.
-            Vector2 targetPoint = (Vector2)pathPoint.Point + new Vector2(-halfWidth, bounds.Top) - bounds.Location - this.textOffset;
+            Vector2 targetPoint = (Vector2)pathPoint.Point + new Vector2(-halfWidth, bounds.Top) - bounds.Location - this.textPathOffset;
 
             // Due to how matrix combining works you have to combine this in the reverse order of operation.
-            this.currentTransform = Matrix3x2.CreateTranslation(targetPoint)
-                * Matrix3x2.CreateRotation(pathPoint.Angle - MathF.PI, pathPoint.Point)
-                * this.drawingOptions.Transform;
-
-            // TODO: This is incorrect. It looks like width/height depends on the rotation.
-            this.currentRenderPosition = Point.Truncate(
-                PointF.Transform(new(bounds.Left + halfWidth, bounds.Bottom), this.currentTransform * origin));
-
-            this.Builder.SetTransform(this.currentTransform);
+            return Matrix3x2.CreateTranslation(targetPoint)
+                * Matrix3x2.CreateRotation(pathPoint.Angle - MathF.PI, pathPoint.Point);
         }
 
         private Buffer2D<float> Render(IPath path)

src/ImageSharp.Drawing/Processing/TextDrawingOptions.cs

@@ -27,8 +27,7 @@ public TextDrawingOptions(Font font)
         /// <param name="options">The options whose properties are copied into this instance.</param>
         public TextDrawingOptions(TextDrawingOptions options)
             : base(options)
-        {
-        }
+            => this.Path = options.Path;
 
         /// <summary>
         /// Gets or sets an optional collection of text runs to apply to the body of text.

src/ImageSharp.Drawing/Shapes/PathBuilder.cs

@@ -41,11 +41,11 @@ public PathBuilder(Matrix3x2 defaultTransform)
         /// <summary>
         /// Sets the translation to be applied to all items to follow being applied to the <see cref="PathBuilder"/>.
         /// </summary>
-        /// <param name="translation">The translation.</param>
+        /// <param name="transform">The transform.</param>
         /// <returns>The <see cref="PathBuilder"/>.</returns>
-        public PathBuilder SetTransform(Matrix3x2 translation)
+        public PathBuilder SetTransform(Matrix3x2 transform)
         {
-            this.setTransform = translation;
+            this.setTransform = transform;
             this.currentTransform = this.setTransform * this.defaultTransform;
             return this;
         }
@@ -57,7 +57,7 @@ public PathBuilder SetTransform(Matrix3x2 translation)
         /// <returns>The <see cref="PathBuilder"/>.</returns>
         public PathBuilder SetOrigin(PointF origin)
         {
-            // the new origin should be transformed based on the default transform
+            // The new origin should be transformed based on the default transform
             this.setTransform.Translation = origin;
             this.currentTransform = this.setTransform * this.defaultTransform;
 

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

@@ -587,15 +587,15 @@ public void DrawRichTextArabic<TPixel>(
         }
 
         [Theory]
-        [WithSolidFilledImages(1000, 1000, nameof(Color.Black), PixelTypes.Rgba32, 32)]
+        [WithSolidFilledImages(500, 200, nameof(Color.Black), PixelTypes.Rgba32, 32)]
         [WithSolidFilledImages(500, 300, nameof(Color.Black), PixelTypes.Rgba32, 40)]
         public void DrawRichTextRainbow<TPixel>(
            TestImageProvider<TPixel> provider,
            int fontSize)
            where TPixel : unmanaged, IPixel<TPixel>
         {
             Font font = CreateFont(TestFonts.OpenSans, fontSize);
-            const string text = "abcdefg";//"The quick brown fox jumps over the lazy dog";
+            const string text = "The quick brown fox jumps over the lazy dog";
 
             SolidPen[] colors = new[]
             {
@@ -616,20 +616,15 @@ public void DrawRichTextRainbow<TPixel>(
                 {
                     Start = i,
                     End = i + 1,
-                    StrikeoutPen = pen
+                    UnderlinePen = pen
                 });
             }
 
-            string svgPath = "M275 175 A100 100 0 1 1 275 174";
-            bool parsed = Path.TryParseSvgPath(svgPath, out IPath path);
-            Assert.True(parsed);
-
             TextDrawingOptions textOptions = new(font)
             {
-                //Origin = new Vector2(-100),
+                Origin = new Vector2(15),
                 WrappingLength = 400,
                 TextRuns = runs,
-                Path = path
             };
 
             provider.RunValidatingProcessorTest(