Expand layer effect bounds using reach

Introduce a `Reach` contract on `LayerEffect` and implement effect-specific reach values (blur, glow, shadows, color matrix, backdrop) so layer processing can reserve enough pixels for blur spread and offsets. `DrawingCanvas.SaveLayer` now inflates content/region bounds by effect reach to prevent clipped output, and a new SaveLayer blur test covers the box-shadow-style case where output must extend and feather beyond the original content bounds.

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/BackdropLayerEffect.cs

@@ -31,6 +31,12 @@ protected BackdropLayerEffect(BackdropLayerEffect fallbackEffect)
         : base(fallbackEffect)
     {
     }
+
+    /// <summary>
+    /// Gets the output reach. Backdrop effects filter the pixels already beneath the layer
+    /// clipped to the region, so their output never extends past it.
+    /// </summary>
+    public sealed override int Reach => 0;
 }
 
 /// <summary>
@@ -56,7 +62,7 @@ public BackdropBlurLayerEffect(float sigma)
     public float Sigma { get; }
 
     /// <inheritdoc/>
-    internal override bool IsPassThrough => this.Sigma == 0;
+    public override bool IsPassThrough => this.Sigma == 0;
 }
 
 /// <summary>
@@ -163,11 +169,11 @@ public BackdropDropShadowLayerEffect(Point offset, float sigma, Color color)
     public Color Color { get; }
 
     /// <inheritdoc/>
-    internal override GraphicsOptions? WriteBackOptions
+    public override GraphicsOptions? WriteBackOptions
         => new() { AlphaCompositionMode = PixelAlphaCompositionMode.DestOver };
 
     /// <inheritdoc/>
-    internal override Point WriteBackOffset => this.Offset;
+    public override Point WriteBackOffset => this.Offset;
 
     /// <summary>
     /// Creates the CPU backdrop drop-shadow operation for the supplied effect values.
@@ -219,7 +225,7 @@ public BackdropColorMatrixLayerEffect(ColorMatrix matrix)
     public ColorMatrix Matrix { get; }
 
     /// <inheritdoc/>
-    internal override bool IsPassThrough => this.Matrix == ColorMatrix.Identity;
+    public override bool IsPassThrough => this.Matrix == ColorMatrix.Identity;
 }
 
 /// <summary>

src/ImageSharp.Drawing/Processing/DrawingCanvas{TPixel}.cs

@@ -413,6 +413,10 @@ public override int SaveLayer(GraphicsOptions layerOptions, IPath region, LayerE
     private int SaveEffectLayerCore(GraphicsOptions layerOptions, Rectangle bounds, LayerEffect effect, DrawingOptions? options)
     {
         Guard.NotNull(effect, nameof(effect));
+
+        // Rectangular content bounds grow into the effect region here so blurred and offset
+        // output spills naturally around the content instead of being cut at its edge.
+        bounds.Inflate(effect.Reach, effect.Reach);
         return this.SaveEffectLayerCore(layerOptions, new RectanglePolygon(bounds), effect, options);
     }
 
@@ -433,12 +437,15 @@ private int SaveEffectLayerCore(GraphicsOptions layerOptions, IPath region, Laye
         Guard.NotNull(region, nameof(region));
         Guard.NotNull(effect, nameof(effect));
 
+        // The layer must contain the effect output, including pixels the write-back lands beyond
+        // the region when the effect carries an offset.
         RectangleF regionBounds = region.Bounds;
+        int reach = Math.Max(effect.Reach, 1);
         Rectangle layerBounds = Rectangle.FromLTRB(
-            (int)MathF.Floor(regionBounds.Left),
-            (int)MathF.Floor(regionBounds.Top),
-            (int)MathF.Ceiling(regionBounds.Right),
-            (int)MathF.Ceiling(regionBounds.Bottom));
+            (int)MathF.Floor(regionBounds.Left) - reach,
+            (int)MathF.Floor(regionBounds.Top) - reach,
+            (int)MathF.Ceiling(regionBounds.Right) + reach,
+            (int)MathF.Ceiling(regionBounds.Bottom) + reach);
 
         DrawingCanvasState currentState = this.ResolveState();
 

src/ImageSharp.Drawing/Processing/LayerEffect.cs

@@ -16,6 +16,7 @@ public abstract class LayerEffect
     private readonly GraphicsOptions? writeBackOptions;
     private readonly Point writeBackOffset;
     private readonly Action<IImageProcessingContext> operation;
+    private readonly int reach;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="LayerEffect"/> class.
@@ -39,25 +40,33 @@ protected LayerEffect(LayerEffect fallbackEffect)
         this.writeBackOptions = fallbackEffect.WriteBackOptions;
         this.writeBackOffset = fallbackEffect.WriteBackOffset;
         this.operation = fallbackEffect.CreateOperation();
+        this.reach = fallbackEffect.Reach;
     }
 
+    /// <summary>
+    /// Gets the distance, in pixels, the effect can push content beyond its source region. Layer
+    /// and processing bounds are expanded by this reach so the effect output is not cut off.
+    /// Effects constructed over a fallback inherit the fallback's reach.
+    /// </summary>
+    public virtual int Reach => this.reach;
+
     /// <summary>
     /// Gets a value indicating whether the effect leaves the layer content unchanged, in which
     /// case its application is skipped entirely.
     /// </summary>
-    internal virtual bool IsPassThrough => this.isPassThrough;
+    public virtual bool IsPassThrough => this.isPassThrough;
 
     /// <summary>
     /// Gets the graphics options used to composite the processed pixels back onto the layer, or
     /// <see langword="null"/> to replace the processed region outright.
     /// </summary>
-    internal virtual GraphicsOptions? WriteBackOptions => this.writeBackOptions;
+    public virtual GraphicsOptions? WriteBackOptions => this.writeBackOptions;
 
     /// <summary>
     /// Gets the offset, in pixels, at which the processed pixels are written back relative to the
     /// region they were read from.
     /// </summary>
-    internal virtual Point WriteBackOffset => this.writeBackOffset;
+    public virtual Point WriteBackOffset => this.writeBackOffset;
 
     /// <summary>
     /// Creates the image-processing operation that transforms the layer snapshot into the effect
@@ -89,13 +98,16 @@ public BlurLayerEffect(float sigma)
     public float Sigma { get; }
 
     /// <inheritdoc/>
-    internal override bool IsPassThrough => this.Sigma == 0;
+    public override int Reach => (int)MathF.Ceiling(this.Sigma * 3F) + 1;
 
     /// <inheritdoc/>
-    internal override GraphicsOptions? WriteBackOptions => null;
+    public override bool IsPassThrough => this.Sigma == 0;
 
     /// <inheritdoc/>
-    internal override Point WriteBackOffset => default;
+    public override GraphicsOptions? WriteBackOptions => null;
+
+    /// <inheritdoc/>
+    public override Point WriteBackOffset => default;
 }
 
 /// <summary>
@@ -138,11 +150,15 @@ public DropShadowLayerEffect(Point offset, float sigma, Color color)
     public Color Color { get; }
 
     /// <inheritdoc/>
-    internal override GraphicsOptions? WriteBackOptions
+    public override int Reach
+        => (int)MathF.Ceiling(this.Sigma * 3F) + Math.Max(Math.Abs(this.Offset.X), Math.Abs(this.Offset.Y)) + 1;
+
+    /// <inheritdoc/>
+    public override GraphicsOptions? WriteBackOptions
         => new() { AlphaCompositionMode = PixelAlphaCompositionMode.DestOver };
 
     /// <inheritdoc/>
-    internal override Point WriteBackOffset => this.Offset;
+    public override Point WriteBackOffset => this.Offset;
 
     /// <summary>
     /// Creates the CPU drop-shadow operation for the supplied effect values.
@@ -207,11 +223,14 @@ public GlowLayerEffect(float sigma, Color color)
     public Color Color { get; }
 
     /// <inheritdoc/>
-    internal override GraphicsOptions? WriteBackOptions
+    public override int Reach => (int)MathF.Ceiling(this.Sigma * 3F) + 1;
+
+    /// <inheritdoc/>
+    public override GraphicsOptions? WriteBackOptions
         => new() { AlphaCompositionMode = PixelAlphaCompositionMode.DestOver };
 
     /// <inheritdoc/>
-    internal override Point WriteBackOffset => default;
+    public override Point WriteBackOffset => default;
 
     /// <summary>
     /// Creates the CPU glow operation for the supplied effect values.
@@ -284,11 +303,15 @@ public InnerShadowLayerEffect(Point offset, float sigma, Color color)
     public Color Color { get; }
 
     /// <inheritdoc/>
-    internal override GraphicsOptions? WriteBackOptions
+    public override int Reach
+        => (int)MathF.Ceiling(this.Sigma * 3F) + Math.Max(Math.Abs(this.Offset.X), Math.Abs(this.Offset.Y)) + 1;
+
+    /// <inheritdoc/>
+    public override GraphicsOptions? WriteBackOptions
         => new() { AlphaCompositionMode = PixelAlphaCompositionMode.SrcAtop };
 
     /// <inheritdoc/>
-    internal override Point WriteBackOffset => this.Offset;
+    public override Point WriteBackOffset => this.Offset;
 
     /// <summary>
     /// Creates the CPU inner-shadow operation for the supplied effect values.
@@ -343,11 +366,14 @@ public ColorMatrixLayerEffect(ColorMatrix matrix)
     public ColorMatrix Matrix { get; }
 
     /// <inheritdoc/>
-    internal override GraphicsOptions? WriteBackOptions => null;
+    public override int Reach => 0;
+
+    /// <inheritdoc/>
+    public override GraphicsOptions? WriteBackOptions => null;
 
     /// <inheritdoc/>
-    internal override Point WriteBackOffset => default;
+    public override Point WriteBackOffset => default;
 
     /// <inheritdoc/>
-    internal override bool IsPassThrough => this.Matrix == ColorMatrix.Identity;
+    public override bool IsPassThrough => this.Matrix == ColorMatrix.Identity;
 }

tests/ImageSharp.Drawing.Tests/Processing/DrawingCanvasTests.SaveLayer.cs

@@ -370,4 +370,34 @@ public void SaveLayer_Apply_CompositesLayerOpacityAfterProcessing<TPixel>(TestIm
         Assert.Equal(255, blended.B);
         Assert.Equal(255, blended.A);
     }
+
+    [Theory]
+    [WithSolidFilledImages(240, 160, nameof(Color.White), PixelTypes.Rgba32)]
+    public void SaveLayer_BlurEffect_OutputReachesBeyondContentBounds<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> target = provider.GetImage();
+
+        // The box-shadow pattern: a blur effect layer whose bounds equal the shadow geometry
+        // exactly, relying on the canvas to expand the effect region by the blur's reach.
+        Rectangle content = new(60, 40, 120, 80);
+        using (DrawingCanvas<TPixel> canvas = CreateCanvas(provider, target, new DrawingOptions()))
+        {
+            canvas.Clear(Brushes.Solid(Color.White));
+            canvas.SaveLayer(new GraphicsOptions(), content, new BlurLayerEffect(6F));
+            canvas.Fill(Brushes.Solid(Color.Black), new RectanglePolygon((RectangleF)content));
+            canvas.Restore();
+        }
+
+        target.DebugSave(provider, appendSourceFileOrDescription: false);
+
+        // Blurred ink must spill outside the content rectangle, and the boundary column must
+        // no longer be a hard edge: without reach expansion the output clamps to the content
+        // bounds, leaving pure white one pixel outside and pure black one pixel inside.
+        Rgba32 outside = target[content.Right + 4, content.Top + (content.Height / 2)].ToRgba32();
+        Assert.True(outside.R < 250, $"Expected blurred ink beyond the content edge but found {outside}.");
+
+        Rgba32 edge = target[content.Right - 1, content.Top + (content.Height / 2)].ToRgba32();
+        Assert.True(edge.R > 5, $"Expected the content edge to feather but found {edge}.");
+    }
 }