Pass composition options to Fill

Author: JimBobSquarePants

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

@@ -60,16 +60,4 @@ internal static DrawingOptions CloneForClearOperation(this DrawingOptions drawin
 
         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/FillPathCollectionExtensions.cs

@@ -1,7 +1,6 @@
 // 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;
@@ -49,7 +48,7 @@ public static IImageProcessingContext Fill(
         Brush brush,
         Pen pen,
         IReadOnlyList<GlyphPathCollection> paths)
-        => source.Fill(options, brush, pen, paths, static (gp, layer) =>
+        => source.Fill(options, brush, pen, paths, static (gp, layer, path) =>
         {
             if (layer.Kind == GlyphLayerKind.Decoration)
             {
@@ -64,22 +63,19 @@ public static IImageProcessingContext Fill(
             }
 
             // 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;
+            // Use the bounding box area as an approximation of the glyph area as it is cheaper to compute.
+            float glyphArea = gp.Bounds.Width * gp.Bounds.Height;
+            float layerArea = path.ComputeArea();
 
-            if (glyphBounds.Width <= 0 || glyphBounds.Height <= 0)
+            if (layerArea <= 0 || glyphArea <= 0)
             {
-                return true; // degenerate glyph, just fill
+                return false; // degenerate glyph, don't fill
             }
 
-            // Use each dimension independently to avoid misclassifying thin layers.
-            float rx = layerBounds.Width / glyphBounds.Width;
-            float ry = layerBounds.Height / glyphBounds.Height;
+            float coverage = layerArea / glyphArea;
 
-            // ≥50% coverage, stroke (don't fill). Otherwise, fill.
-            return rx < 0.5F || ry < 0.5F;
+            // <50% coverage, fill. Otherwise, stroke.
+            return coverage < 0.50F;
         });
 
     /// <summary>
@@ -91,15 +87,17 @@ public static IImageProcessingContext Fill(
     /// <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>
+    /// <param name="shouldFillLayer">
+    /// A function that decides whether to fill or stroke a given layer within a multi-layer (painted) glyph.
+    /// </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)
+        Func<GlyphPathCollection, GlyphLayerInfo, IPath, bool> shouldFillLayer)
     {
         foreach (GlyphPathCollection gp in paths)
         {
@@ -121,14 +119,15 @@ public static IImageProcessingContext Fill(
                 GlyphLayerInfo layer = gp.Layers[i];
                 IPath path = gp.PathList[i];
 
-                if (shouldFillLayer(gp, layer))
+                if (shouldFillLayer(gp, layer, path))
                 {
-                    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);
+                    DrawingOptions o = options.CloneOrReturnForRules(
+                        layer.IntersectionRule,
+                        layer.PixelAlphaCompositionMode,
+                        layer.PixelColorBlendingMode);
+
+                    source.Fill(o, brush, path);
                 }
                 else
                 {

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

@@ -144,10 +144,8 @@ protected override void BeginGlyph(in FontRectangle bounds, in GlyphRendererPara
         this.rasterizationRequired = true;
     }
 
-    protected override void BeginLayer(Paint? paint, FillRule fillRule, in FontRectangle? clipBounds)
+    protected override void BeginLayer(Paint? paint, FillRule fillRule, in ClipQuad? clipBounds)
     {
-        // TODO: We may have do some sort of translation based on the delta
-        // between the bounds and clipbounds.
         this.hasLayer = true;
         if (TryCreateBrush(paint, this.Builder.Transform, out Brush? brush))
         {
@@ -657,7 +655,6 @@ public static CacheKey FromParameters(in GlyphRendererParameters parameters, Rec
             {
                 // Our caching does not need the grapheme index as that is only relevant to the text layout.
                 Font = parameters.Font,
-                GlyphColor = parameters.GlyphColor,
                 GlyphType = parameters.GlyphType,
                 FontStyle = parameters.FontStyle,
                 GlyphId = parameters.GlyphId,

src/ImageSharp.Drawing/Shapes/PathExtensions.cs

@@ -149,10 +149,70 @@ public static float ComputeLength(this IPath path)
 
             if (s.IsClosed)
             {
-                dist += Vector2.Distance(points[0], points[points.Length - 1]);
+                dist += Vector2.Distance(points[0], points[^1]);
             }
         }
 
         return dist;
     }
+
+    /// <summary>
+    /// Calculates the total area of all paths in the specified collection.
+    /// </summary>
+    /// <param name="paths">A collection of paths for which to compute the combined area. Cannot be null.</param>
+    /// <returns>
+    /// The total area, in square units, enclosed by all paths in the collection.
+    /// </returns>
+    public static float ComputeArea(this IPathCollection paths)
+    {
+        float area = 0;
+        foreach (IPath path in paths)
+        {
+            area += path.ComputeArea();
+        }
+
+        return area;
+    }
+
+    /// <summary>
+    /// Calculates the total area enclosed by the specified path.
+    /// </summary>
+    /// <remarks>
+    /// This method sums the areas of all subpaths within the path. Subpaths with fewer than three
+    /// points are ignored, as they do not form a closed region. The result is always non-negative, regardless of the
+    /// winding direction of the subpaths.
+    /// </remarks>
+    /// <param name="path">
+    /// The path for which to compute the enclosed area. Must contain at least one subpath with three or more points to
+    /// contribute to the area calculation.
+    /// </param>
+    /// <returns>
+    /// The total area, in square units, enclosed by all subpaths of the path. Returns 0 if the path does not contain
+    /// any subpaths with at least three points.
+    /// </returns>
+    public static float ComputeArea(this IPath path)
+    {
+        float area = 0;
+        foreach (ISimplePath s in path.Flatten())
+        {
+            ReadOnlySpan<PointF> points = s.Points.Span;
+            if (points.Length < 3)
+            {
+                // Not enough points to form an area
+                continue;
+            }
+
+            float subArea = 0;
+            for (int i = 0; i < points.Length; i++)
+            {
+                PointF p1 = points[i];
+                PointF p2 = points[(i + 1) % points.Length];
+                subArea += (p1.X * p2.Y) - (p2.X * p1.Y);
+            }
+
+            area += MathF.Abs(subArea) * .5F;
+        }
+
+        return area;
+    }
 }

src/ImageSharp.Drawing/Shapes/Text/BaseGlyphBuilder.cs

@@ -36,7 +36,7 @@ internal class BaseGlyphBuilder : IGlyphRenderer
     private int layerStartIndex;
     private Paint? activeLayerPaint;
     private FillRule activeLayerFillRule;
-    private FontRectangle? activeClipBounds;
+    private ClipQuad? activeClipBounds;
 
     public BaseGlyphBuilder() => this.Builder = new PathBuilder();
 
@@ -188,7 +188,7 @@ void IGlyphRenderer.QuadraticBezierTo(Vector2 secondControlPoint, Vector2 point)
     }
 
     /// <inheritdoc/>
-    void IGlyphRenderer.BeginLayer(Paint? paint, FillRule fillRule, in FontRectangle? clipBounds)
+    void IGlyphRenderer.BeginLayer(Paint? paint, FillRule fillRule, in ClipQuad? clipBounds)
     {
         this.usedLayers = true;
         this.inLayer = true;
@@ -211,7 +211,11 @@ void IGlyphRenderer.EndLayer()
 
         IPath path = this.Builder.Build();
 
-        // TODO: We need to clip the path by activeClipBounds if set.
+        if (this.activeClipBounds is not null)
+        {
+            // TODO:Clipping not yet implemented.
+        }
+
         this.CurrentPaths.Add(path);
 
         if (this.graphemeBuilder is not null)
@@ -392,8 +396,8 @@ protected virtual void EndText()
     {
     }
 
-    /// <inheritdoc cref="IGlyphRenderer.BeginLayer(Paint?, FillRule, in FontRectangle?)"/>
-    protected virtual void BeginLayer(Paint? paint, FillRule fillRule, in FontRectangle? clipBounds)
+    /// <inheritdoc cref="IGlyphRenderer.BeginLayer(Paint?, FillRule, in ClipQuad?)"/>
+    protected virtual void BeginLayer(Paint? paint, FillRule fillRule, in ClipQuad? clipBounds)
     {
     }
 

src/ImageSharp.Drawing/Shapes/Text/GlyphLayerInfo.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Numerics;
 using SixLabors.Fonts.Rendering;
 
 namespace SixLabors.ImageSharp.Drawing.Shapes.Text;
@@ -19,12 +20,42 @@ public readonly struct GlyphLayerInfo
     /// <param name="fillRule">The fill rule to use for this layer.</param>
     /// <param name="bounds">Axis-aligned bounds of the layer geometry.</param>
     /// <param name="kind">An optional semantic hint for the layer type.</param>
-    public GlyphLayerInfo(int startIndex, int count, Paint? paint, FillRule fillRule, RectangleF bounds, GlyphLayerKind kind = GlyphLayerKind.Glyph)
+    internal GlyphLayerInfo(
+        int startIndex,
+        int count,
+        Paint? paint,
+        FillRule fillRule,
+        RectangleF bounds,
+        GlyphLayerKind kind)
     {
         this.StartIndex = startIndex;
         this.Count = count;
         this.Paint = paint;
-        this.FillRule = fillRule;
+        this.IntersectionRule = TextUtilities.MapFillRule(fillRule);
+
+        CompositeMode compositeMode = paint?.CompositeMode ?? CompositeMode.SrcOver;
+        this.PixelAlphaCompositionMode = TextUtilities.MapCompositionMode(compositeMode);
+        this.PixelColorBlendingMode = TextUtilities.MapBlendingMode(compositeMode);
+        this.Bounds = bounds;
+        this.Kind = kind;
+    }
+
+    private GlyphLayerInfo(
+        int startIndex,
+        int count,
+        Paint? paint,
+        IntersectionRule intersectionRule,
+        PixelAlphaCompositionMode compositionMode,
+        PixelColorBlendingMode colorBlendingMode,
+        RectangleF bounds,
+        GlyphLayerKind kind)
+    {
+        this.StartIndex = startIndex;
+        this.Count = count;
+        this.Paint = paint;
+        this.IntersectionRule = intersectionRule;
+        this.PixelAlphaCompositionMode = compositionMode;
+        this.PixelColorBlendingMode = colorBlendingMode;
         this.Bounds = bounds;
         this.Kind = kind;
     }
@@ -47,7 +78,17 @@ public GlyphLayerInfo(int startIndex, int count, Paint? paint, FillRule fillRule
     /// <summary>
     /// Gets the fill rule for rasterization of this layer.
     /// </summary>
-    public FillRule FillRule { get; }
+    public IntersectionRule IntersectionRule { get; }
+
+    /// <summary>
+    /// Gets the pixel alpha composition mode to use for this layer.
+    /// </summary>
+    public PixelAlphaCompositionMode PixelAlphaCompositionMode { get; }
+
+    /// <summary>
+    /// Gets the pixel color blending mode to use for this layer.
+    /// </summary>
+    public PixelColorBlendingMode PixelColorBlendingMode { get; }
 
     /// <summary>
     /// Gets the bounds of the layer geometry (device space).
@@ -58,4 +99,15 @@ public GlyphLayerInfo(int startIndex, int count, Paint? paint, FillRule fillRule
     /// Gets the semantic kind of the layer (for policy decisions).
     /// </summary>
     public GlyphLayerKind Kind { get; }
+
+    internal static GlyphLayerInfo Transform(in GlyphLayerInfo info, Matrix3x2 matrix)
+        => new(
+            info.StartIndex,
+            info.Count,
+            info.Paint,
+            info.IntersectionRule,
+            info.PixelAlphaCompositionMode,
+            info.PixelColorBlendingMode,
+            RectangleF.Transform(info.Bounds, matrix),
+            info.Kind);
 }

src/ImageSharp.Drawing/Shapes/Text/GlyphPathCollection.cs

@@ -66,30 +66,23 @@ internal GlyphPathCollection(List<IPath> paths, List<GlyphLayerInfo> layers)
     /// <summary>
     /// Transforms the glyph using the specified matrix.
     /// </summary>
-    /// <param name="transform">The matrix.</param>
+    /// <param name="matrix">The transform matrix.</param>
     /// <returns>
     /// A new <see cref="GlyphPathCollection"/> with the matrix applied to it.
     /// </returns>
-    public GlyphPathCollection Translate(Matrix3x2 transform)
+    public GlyphPathCollection Transform(Matrix3x2 matrix)
     {
         List<IPath> transformed = new(this.paths.Count);
 
         for (int i = 0; i < this.paths.Count; i++)
         {
-            transformed.Add(this.paths[i].Transform(transform));
+            transformed.Add(this.paths[i].Transform(matrix));
         }
 
         List<GlyphLayerInfo> transformedLayers = new(this.layers.Count);
         for (int i = 0; i < this.layers.Count; i++)
         {
-            GlyphLayerInfo li = this.layers[i];
-            RectangleF bounds = li.Bounds;
-            if (bounds != RectangleF.Empty)
-            {
-                bounds = RectangleF.Transform(bounds, transform);
-            }
-
-            transformedLayers.Add(new GlyphLayerInfo(li.StartIndex, li.Count, li.Paint, li.FillRule, bounds, li.Kind));
+            transformedLayers.Add(GlyphLayerInfo.Transform(this.layers[i], matrix));
         }
 
         return new GlyphPathCollection(transformed, transformedLayers);
@@ -101,7 +94,7 @@ public GlyphPathCollection Translate(Matrix3x2 transform)
     /// </summary>
     /// <param name="predicate">A filter deciding whether to keep a layer.</param>
     /// <returns>A new <see cref="PathCollection"/> with the selected paths.</returns>
-    public PathCollection ToPathCollection(Func<GlyphLayerInfo, bool>? predicate)
+    public PathCollection ToPathCollection(Func<GlyphLayerInfo, bool>? predicate = null)
     {
         List<IPath> kept = [];
         for (int i = 0; i < this.layers.Count; i++)
@@ -165,7 +158,13 @@ internal sealed class Builder
         /// <param name="fillRule">The fill rule for this layer.</param>
         /// <param name="bounds">Optional cached bounds for this layer.</param>
         /// <param name="kind">Optional semantic kind (eg. Decoration).</param>
-        public void AddLayer(int startIndex, int count, Paint? paint, FillRule fillRule, RectangleF bounds, GlyphLayerKind kind = GlyphLayerKind.Glyph)
+        public void AddLayer(
+            int startIndex,
+            int count,
+            Paint? paint,
+            FillRule fillRule,
+            RectangleF bounds,
+            GlyphLayerKind kind = GlyphLayerKind.Glyph)
         {
             if (startIndex < 0 || count < 0 || startIndex + count > this.paths.Count)
             {