Avoid crop

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/ImageBrush.cs

@@ -18,13 +18,27 @@ public class ImageBrush : IBrush
         /// </summary>
         private readonly Image image;
 
+        private readonly RectangleF? region;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ImageBrush"/> class.
         /// </summary>
         /// <param name="image">The image.</param>
         public ImageBrush(Image image)
+            => this.image = image;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ImageBrush"/> class.
+        /// </summary>
+        /// <param name="image">The image.</param>
+        /// <param name="region">
+        /// The region of interest.
+        /// This overrides any region used to intitialize the brush applicator.
+        /// </param>
+        internal ImageBrush(Image image, RectangleF region)
         {
             this.image = image;
+            this.region = region;
         }
 
         /// <inheritdoc />
@@ -35,19 +49,22 @@ public BrushApplicator<TPixel> CreateApplicator<TPixel>(
             RectangleF region)
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            RectangleF interest = this.region ?? region;
+
             if (this.image is Image<TPixel> specificImage)
             {
-                return new ImageBrushApplicator<TPixel>(configuration, options, source, specificImage, region, false);
+                return new ImageBrushApplicator<TPixel>(configuration, options, source, specificImage, interest, false);
             }
 
             specificImage = this.image.CloneAs<TPixel>();
 
-            return new ImageBrushApplicator<TPixel>(configuration, options, source, specificImage, region, true);
+            return new ImageBrushApplicator<TPixel>(configuration, options, source, specificImage, interest, true);
         }
 
         /// <summary>
         /// The image brush applicator.
         /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
         private class ImageBrushApplicator<TPixel> : BrushApplicator<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
@@ -139,32 +156,30 @@ public override void Apply(Span<float> scanline, int x, int y)
             {
                 // Create a span for colors
                 MemoryAllocator allocator = this.Configuration.MemoryAllocator;
-                using (IMemoryOwner<float> amountBuffer = allocator.Allocate<float>(scanline.Length))
-                using (IMemoryOwner<TPixel> overlay = allocator.Allocate<TPixel>(scanline.Length))
+                using IMemoryOwner<float> amountBuffer = allocator.Allocate<float>(scanline.Length);
+                using IMemoryOwner<TPixel> overlay = allocator.Allocate<TPixel>(scanline.Length);
+                Span<float> amountSpan = amountBuffer.Memory.Span;
+                Span<TPixel> overlaySpan = overlay.Memory.Span;
+
+                int sourceY = (y - this.offsetY) % this.yLength;
+                int offsetX = x - this.offsetX;
+                Span<TPixel> sourceRow = this.sourceFrame.GetPixelRowSpan(sourceY);
+
+                for (int i = 0; i < scanline.Length; i++)
                 {
-                    Span<float> amountSpan = amountBuffer.Memory.Span;
-                    Span<TPixel> overlaySpan = overlay.Memory.Span;
-
-                    int sourceY = (y - this.offsetY) % this.yLength;
-                    int offsetX = x - this.offsetX;
-                    Span<TPixel> sourceRow = this.sourceFrame.GetPixelRowSpan(sourceY);
-
-                    for (int i = 0; i < scanline.Length; i++)
-                    {
-                        amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
-
-                        int sourceX = (i + offsetX) % this.xLength;
-                        overlaySpan[i] = sourceRow[sourceX];
-                    }
-
-                    Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(
-                        this.Configuration,
-                        destinationRow,
-                        destinationRow,
-                        overlaySpan,
-                        amountSpan);
+                    amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
+
+                    int sourceX = (i + offsetX) % this.xLength;
+                    overlaySpan[i] = sourceRow[sourceX];
                 }
+
+                Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
+                this.Blender.Blend(
+                    this.Configuration,
+                    destinationRow,
+                    destinationRow,
+                    overlaySpan,
+                    amountSpan);
             }
         }
     }

src/ImageSharp.Drawing/Processing/Processors/Drawing/RecursiveImageProcessor.cs

@@ -77,17 +77,16 @@ public void Dispose()
             public void Execute()
             {
                 // Perform any processing logic you want here, in this case we are going to
-                // clone the source image then apply the changes requested before cropping
-                // down and using an image brush to draw that portion the the original image
+                // clone the source image then apply the changes requested before using an
+                // image brush to draw that portion the the original image
                 // so clone out our source image so we can apply
                 // various effects to it without mutating the origional yet.
                 using Image<TPixel> clone = this.source.Clone(this.recursiveImageProcessor.Operation);
 
-                // Crop it down to just the size of the shape
-                clone.Mutate(x => x.Crop((Rectangle)this.recursiveImageProcessor.Path.Bounds));
-
-                // Use an image brush to apply cloned image as the source for filling the shape
-                var brush = new ImageBrush(clone);
+                // Use an image brush to apply cloned image as the source for filling the shape.
+                // We pass explicit bounds to avoid the need to crop the clone;
+                RectangleF bounds = this.recursiveImageProcessor.Path.Bounds;
+                var brush = new ImageBrush(clone, new RectangleF(0, 0, bounds.Width, bounds.Height));
 
                 // Grab hold of an image processor that can fill paths with a brush to allow it to do the hard pixel pushing for us
                 var processor = new FillPathProcessor(this.recursiveImageProcessor.Options, brush, this.recursiveImageProcessor.Path);