Fix layerd rendering

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Extensions/ClearExtensions.cs

@@ -54,10 +54,22 @@ public static IImageProcessingContext Clear(this IImageProcessingContext source,
     internal static DrawingOptions CloneForClearOperation(this DrawingOptions drawingOptions)
     {
         GraphicsOptions options = drawingOptions.GraphicsOptions.DeepClone();
-        options.ColorBlendingMode = PixelFormats.PixelColorBlendingMode.Normal;
-        options.AlphaCompositionMode = PixelFormats.PixelAlphaCompositionMode.Src;
+        options.ColorBlendingMode = PixelColorBlendingMode.Normal;
+        options.AlphaCompositionMode = PixelAlphaCompositionMode.Src;
         options.BlendPercentage = 1F;
 
         return new DrawingOptions(options, drawingOptions.ShapeOptions, drawingOptions.Transform);
     }
+
+    internal static DrawingOptions CloneOrReturnForIntersectionRule(this DrawingOptions drawingOptions, IntersectionRule intersectionRule)
+    {
+        if (drawingOptions.ShapeOptions.IntersectionRule == intersectionRule)
+        {
+            return drawingOptions;
+        }
+
+        ShapeOptions shapeOptions = drawingOptions.ShapeOptions.DeepClone();
+        shapeOptions.IntersectionRule = intersectionRule;
+        return new DrawingOptions(drawingOptions.GraphicsOptions.DeepClone(), shapeOptions, drawingOptions.Transform);
+    }
 }

src/ImageSharp.Drawing/Processing/Extensions/DrawPathCollectionExtensions.cs

@@ -38,8 +38,8 @@ public static IImageProcessingContext Draw(
     /// <param name="paths">The paths.</param>
     /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
     public static IImageProcessingContext
-        Draw(this IImageProcessingContext source, Pen pen, IPathCollection paths) =>
-        source.Draw(source.GetDrawingOptions(), pen, paths);
+        Draw(this IImageProcessingContext source, Pen pen, IPathCollection paths)
+        => source.Draw(source.GetDrawingOptions(), pen, paths);
 
     /// <summary>
     /// Draws the outline of the polygon with the provided brush at the provided thickness.

src/ImageSharp.Drawing/Processing/Extensions/FillPathCollectionExtensions.cs

@@ -1,6 +1,9 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.Fonts.Rendering;
+using SixLabors.ImageSharp.Drawing.Shapes.Text;
+
 namespace SixLabors.ImageSharp.Drawing.Processing;
 
 /// <summary>
@@ -14,7 +17,7 @@ public static class FillPathCollectionExtensions
     /// <param name="source">The source image processing context.</param>
     /// <param name="options">The graphics options.</param>
     /// <param name="brush">The brush.</param>
-    /// <param name="paths">The shapes.</param>
+    /// <param name="paths">The collection of paths.</param>
     /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
     public static IImageProcessingContext Fill(
         this IImageProcessingContext source,
@@ -30,12 +33,120 @@ public static IImageProcessingContext Fill(
         return source;
     }
 
+    /// <summary>
+    /// Flood fills the image in the shape of the provided glyphs with the specified brush and pen.
+    /// For multi-layer glyphs, a heuristic is used to decide whether to fill or stroke each layer.
+    /// </summary>
+    /// <param name="source">The source image processing context.</param>
+    /// <param name="options">The graphics options.</param>
+    /// <param name="brush">The brush.</param>
+    /// <param name="pen">The pen.</param>
+    /// <param name="paths">The collection of glyph paths.</param>
+    /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+    public static IImageProcessingContext Fill(
+        this IImageProcessingContext source,
+        DrawingOptions options,
+        Brush brush,
+        Pen pen,
+        IReadOnlyList<GlyphPathCollection> paths)
+        => source.Fill(options, brush, pen, paths, static (gp, layer) =>
+        {
+            if (layer.Kind == GlyphLayerKind.Decoration)
+            {
+                // Decorations (underlines, strikethroughs, etc) are always filled.
+                return true;
+            }
+
+            if (layer.Kind == GlyphLayerKind.Glyph)
+            {
+                // Standard glyph layers are filled by default.
+                return true;
+            }
+
+            // Default heuristic: stroke "background-like" layers (large coverage), fill others.
+            // TODO: We should be using the area, not the bounds. Thin layers with large width/height
+            // will be misclassified. e.g. shadows.
+            RectangleF glyphBounds = gp.Bounds;
+            RectangleF layerBounds = layer.Bounds;
+
+            if (glyphBounds.Width <= 0 || glyphBounds.Height <= 0)
+            {
+                return true; // degenerate glyph, just fill
+            }
+
+            // Use each dimension independently to avoid misclassifying thin layers.
+            float rx = layerBounds.Width / glyphBounds.Width;
+            float ry = layerBounds.Height / glyphBounds.Height;
+
+            // ≥50% coverage, stroke (don't fill). Otherwise, fill.
+            return rx < 0.5F || ry < 0.5F;
+        });
+
+    /// <summary>
+    /// Flood fills the image in the shape of the provided glyphs with the specified brush and pen.
+    /// For multi-layer glyphs, a heuristic is used to decide whether to fill or stroke each layer.
+    /// </summary>
+    /// <param name="source">The source image processing context.</param>
+    /// <param name="options">The graphics options.</param>
+    /// <param name="brush">The brush.</param>
+    /// <param name="pen">The pen.</param>
+    /// <param name="paths">The collection of glyph paths.</param>
+    /// <param name="shouldFillLayer">A function that decides whether to fill or stroke a given layer.</param>
+    /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+    public static IImageProcessingContext Fill(
+        this IImageProcessingContext source,
+        DrawingOptions options,
+        Brush brush,
+        Pen pen,
+        IReadOnlyList<GlyphPathCollection> paths,
+        Func<GlyphPathCollection, GlyphLayerInfo, bool> shouldFillLayer)
+    {
+        foreach (GlyphPathCollection gp in paths)
+        {
+            if (gp.LayerCount == 0)
+            {
+                continue;
+            }
+
+            if (gp.LayerCount == 1)
+            {
+                // Single-layer glyph: just fill with the supplied brush.
+                source.Fill(options, brush, gp.Paths);
+                continue;
+            }
+
+            // Multi-layer: decide per layer whether to fill or stroke.
+            for (int i = 0; i < gp.Layers.Count; i++)
+            {
+                GlyphLayerInfo layer = gp.Layers[i];
+                IPath path = gp.PathList[i];
+
+                if (shouldFillLayer(gp, layer))
+                {
+                    IntersectionRule fillRule = layer.FillRule == FillRule.EvenOdd
+                        ? IntersectionRule.EvenOdd
+                        : IntersectionRule.NonZero;
+
+                    // Respect the layer's fill rule if different to the drawing options.
+                    source.Fill(options.CloneOrReturnForIntersectionRule(fillRule), brush, path);
+                }
+                else
+                {
+                    // Outline only to preserve interior detail.
+                    source.Draw(options, pen, path);
+                }
+            }
+        }
+
+        return source;
+    }
+
     /// <summary>
     /// Flood fills the image in the shape of the provided polygon with the specified brush.
     /// </summary>
     /// <param name="source">The source image processing context.</param>
     /// <param name="brush">The brush.</param>
-    /// <param name="paths">The paths.</param>
+    /// <param name="paths">The collection of paths.</param>
     /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
     public static IImageProcessingContext Fill(
         this IImageProcessingContext source,
@@ -44,7 +155,23 @@ public static IImageProcessingContext Fill(
         source.Fill(source.GetDrawingOptions(), brush, paths);
 
     /// <summary>
-    /// Flood fills the image in the shape of the provided polygon with the specified brush.
+    /// Flood fills the image in the shape of the provided glyphs with the specified brush and pen.
+    /// For multi-layer glyphs, a heuristic is used to decide whether to fill or stroke each layer.
+    /// </summary>
+    /// <param name="source">The source image processing context.</param>
+    /// <param name="brush">The brush.</param>
+    /// <param name="pen">The pen.</param>
+    /// <param name="paths">The collection of glyph paths.</param>
+    /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+    public static IImageProcessingContext Fill(
+        this IImageProcessingContext source,
+        Brush brush,
+        Pen pen,
+        IReadOnlyList<GlyphPathCollection> paths) =>
+        source.Fill(source.GetDrawingOptions(), brush, pen, paths);
+
+    /// <summary>
+    /// Flood fills the image in the shape of the provided polygon with the specified color.
     /// </summary>
     /// <param name="source">The source image processing context.</param>
     /// <param name="options">The options.</param>
@@ -59,15 +186,29 @@ public static IImageProcessingContext Fill(
         source.Fill(options, new SolidBrush(color), paths);
 
     /// <summary>
-    /// Flood fills the image in the shape of the provided polygon with the specified brush.
+    /// Flood fills the image in the shape of the provided polygon with the specified color.
     /// </summary>
     /// <param name="source">The source image processing context.</param>
     /// <param name="color">The color.</param>
-    /// <param name="paths">The paths.</param>
+    /// <param name="paths">The collection of paths.</param>
     /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
     public static IImageProcessingContext Fill(
         this IImageProcessingContext source,
         Color color,
         IPathCollection paths) =>
         source.Fill(new SolidBrush(color), paths);
+
+    /// <summary>
+    /// Flood fills the image in the shape of the provided glyphs with the specified color.
+    /// For multi-layer glyphs, a heuristic is used to decide whether to fill or stroke each layer.
+    /// </summary>
+    /// <param name="source">The source image processing context.</param>
+    /// <param name="color">The color.</param>
+    /// <param name="paths">The collection of glyph paths.</param>
+    /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+    public static IImageProcessingContext Fill(
+        this IImageProcessingContext source,
+        Color color,
+        IReadOnlyList<GlyphPathCollection> paths) =>
+        source.Fill(new SolidBrush(color), new SolidPen(color), paths);
 }

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

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
 using SixLabors.Fonts;
 using SixLabors.Fonts.Rendering;
 
@@ -16,9 +17,10 @@ internal sealed partial class RichTextGlyphRenderer
     /// Attempts to create an ImageSharp.Drawing <see cref="Brush"/> from a <see cref="Paint"/>.
     /// </summary>
     /// <param name="paint">The paint definition coming from the interpreter.</param>
+    /// <param name="transform">A transform to apply to the brush coordinates.</param>
     /// <param name="brush">The resulting brush, or <see langword="null"/> if the paint is unsupported.</param>
     /// <returns><see langword="true"/> if a brush could be created; otherwise, <see langword="false"/>.</returns>
-    public static bool TryCreateBrush(Paint? paint, [NotNullWhen(true)] out Brush? brush)
+    public static bool TryCreateBrush(Paint? paint, Matrix3x2 transform, [NotNullWhen(true)] out Brush? brush)
     {
         brush = null;
 
@@ -27,19 +29,18 @@ public static bool TryCreateBrush(Paint? paint, [NotNullWhen(true)] out Brush? b
             return false;
         }
 
-        // TODO: Do we need to apply the transform assigned to th underlying builder here?
         switch (paint)
         {
             case SolidPaint sp:
                 brush = new SolidBrush(ToColor(sp.Color, sp.Opacity));
                 return true;
 
             case LinearGradientPaint lg:
-                return TryCreateLinearGradientBrush(lg, out brush);
+                return TryCreateLinearGradientBrush(lg, transform, out brush);
             case RadialGradientPaint rg:
-                return TryCreateRadialGradientBrush(rg, out brush);
+                return TryCreateRadialGradientBrush(rg, transform, out brush);
             case SweepGradientPaint sg:
-                return TryCreateSweepGradientBrush(sg, out brush);
+                return TryCreateSweepGradientBrush(sg, transform, out brush);
             default:
                 return false;
         }
@@ -48,27 +49,26 @@ public static bool TryCreateBrush(Paint? paint, [NotNullWhen(true)] out Brush? b
     /// <summary>
     /// Creates a <see cref="LinearGradientBrush"/> from a <see cref="LinearGradientPaint"/>.
     /// </summary>
-    /// <param name="lg">The linear gradient paint.</param>
+    /// <param name="paint">The linear gradient paint.</param>
+    /// <param name="transform">The transform to apply to the gradient points.</param>
     /// <param name="brush">The resulting brush.</param>
     /// <returns><see langword="true"/> if created; otherwise, <see langword="false"/>.</returns>
-    private static bool TryCreateLinearGradientBrush(LinearGradientPaint lg, out Brush? brush)
+    private static bool TryCreateLinearGradientBrush(LinearGradientPaint paint, Matrix3x2 transform, out Brush? brush)
     {
-        // Map gradient stops (apply paint opacity multiplier to each stop’s alpha).
-        ColorStop[] stops = ToColorStops(lg.Stops, lg.Opacity);
+        // Map gradient stops (apply paint opacity multiplier to each stop's alpha).
+        ColorStop[] stops = ToColorStops(paint.Stops, paint.Opacity);
 
         // Map spread method.
-        GradientRepetitionMode mode = MapSpread(lg.Spread);
+        GradientRepetitionMode mode = MapSpread(paint.Spread);
 
-        PointF p0 = lg.P0;
-        PointF p1 = lg.P1;
+        PointF p0 = paint.P0;
+        PointF p1 = paint.P1;
 
-        // Degenerate gradient, fall back to solid using last stop.
-        if (ApproximatelyEqual(p0, p1))
+        // Apply any transform defined on the paint.
+        if (!transform.IsIdentity)
         {
-            // TODO: Consider using this.currentColor instead?
-            Color fallback = stops.Length > 0 ? stops[^1].Color : Color.Black;
-            brush = new SolidBrush(fallback);
-            return true;
+            p0 = Vector2.Transform(p0, transform);
+            p1 = Vector2.Transform(p1, transform);
         }
 
         brush = new LinearGradientBrush(p0, p1, mode, stops);
@@ -78,36 +78,51 @@ private static bool TryCreateLinearGradientBrush(LinearGradientPaint lg, out Bru
     /// <summary>
     /// Creates a <see cref="RadialGradientBrush"/> from a <see cref="RadialGradientPaint"/>.
     /// </summary>
-    /// <param name="rg">The radial gradient paint.</param>
+    /// <param name="paint">The radial gradient paint.</param>
+    /// <param name="transform">The transform to apply to the gradient center point.</param>
     /// <param name="brush">The resulting brush.</param>
     /// <returns><see langword="true"/> if created; otherwise, <see langword="false"/>.</returns>
-    private static bool TryCreateRadialGradientBrush(RadialGradientPaint rg, out Brush? brush)
+    private static bool TryCreateRadialGradientBrush(RadialGradientPaint paint, Matrix3x2 transform, out Brush? brush)
     {
-        // Map gradient stops (apply paint opacity multiplier to each stop’s alpha).
-        ColorStop[] stops = ToColorStops(rg.Stops, rg.Opacity);
+        // Map gradient stops (apply paint opacity multiplier to each stop's alpha).
+        ColorStop[] stops = ToColorStops(paint.Stops, paint.Opacity);
 
         // Map spread method.
-        GradientRepetitionMode mode = MapSpread(rg.Spread);
+        GradientRepetitionMode mode = MapSpread(paint.Spread);
 
-        brush = new RadialGradientBrush(rg.Center, rg.Radius, mode, stops);
+        // Apply any transform defined on the paint.
+        PointF center = paint.Center;
+        if (!transform.IsIdentity)
+        {
+            center = Vector2.Transform(center, transform);
+        }
+
+        brush = new RadialGradientBrush(center, paint.Radius, mode, stops);
         return true;
     }
 
     /// <summary>
     /// Creates a <see cref="SweepGradientBrush"/> from a <see cref="SweepGradientPaint"/>.
     /// </summary>
-    /// <param name="sg">The sweep gradient paint.</param>
+    /// <param name="paint">The sweep gradient paint.</param>
     /// <param name="brush">The resulting brush.</param>
     /// <returns><see langword="true"/> if created; otherwise, <see langword="false"/>.</returns>
-    private static bool TryCreateSweepGradientBrush(SweepGradientPaint sg, out Brush? brush)
+    private static bool TryCreateSweepGradientBrush(SweepGradientPaint paint, Matrix3x2 transform, out Brush? brush)
     {
-        // Map gradient stops (apply paint opacity multiplier to each stop’s alpha).
-        ColorStop[] stops = ToColorStops(sg.Stops, sg.Opacity);
+        // Map gradient stops (apply paint opacity multiplier to each stop's alpha).
+        ColorStop[] stops = ToColorStops(paint.Stops, paint.Opacity);
 
         // Map spread method.
-        GradientRepetitionMode mode = MapSpread(sg.Spread);
+        GradientRepetitionMode mode = MapSpread(paint.Spread);
 
-        brush = new SweepGradientBrush(sg.Center, sg.StartAngle, sg.EndAngle, mode, stops);
+        // Apply any transform defined on the paint.
+        PointF center = paint.Center;
+        if (!transform.IsIdentity)
+        {
+            center = Vector2.Transform(center, transform);
+        }
+
+        brush = new SweepGradientBrush(center, paint.StartAngle, paint.EndAngle, mode, stops);
         return true;
     }
 
@@ -163,14 +178,4 @@ private static Color ToColor(in GlyphColor c, float opacity)
         byte aa = (byte)MathF.Round(a * 255f);
         return Color.FromPixel(new Rgba32(c.Red, c.Green, c.Blue, aa));
     }
-
-    /// <summary>
-    /// Compares two points for near-equality.
-    /// </summary>
-    /// <param name="a">The first point.</param>
-    /// <param name="b">The second point.</param>
-    /// <param name="eps">Tolerance.</param>
-    /// <returns><see langword="true"/> if near-equal; otherwise <see langword="false"/>.</returns>
-    private static bool ApproximatelyEqual(in PointF a, in PointF b, float eps = 1e-4f)
-        => MathF.Abs(a.X - b.X) <= eps && MathF.Abs(a.Y - b.Y) <= eps;
 }