Add new Clip extension and tests

Author: JimBobSquarePants

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

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using SixLabors.ImageSharp.Drawing.Processing.Processors.Drawing;
 using SixLabors.ImageSharp.Processing;
 
 namespace SixLabors.ImageSharp.Drawing.Processing

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

@@ -0,0 +1,28 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.Drawing.Processing.Processors.Drawing;
+using SixLabors.ImageSharp.Processing;
+
+namespace SixLabors.ImageSharp.Drawing.Processing
+{
+    /// <summary>
+    /// Adds extensions that allow the application of processors within a clipped path.
+    /// </summary>
+    public static class ClipPathExtensions
+    {
+        /// <summary>
+        /// Applies the processing operation against a given clipping path.
+        /// </summary>
+        /// <param name="source">The image processing context.</param>
+        /// <param name="path">The target path to operate within.</param>
+        /// <param name="operation">The operation to perform on the source.</param>
+        /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+        public static IImageProcessingContext Clip(
+            this IImageProcessingContext source,
+            IPath path,
+            Action<IImageProcessingContext> operation)
+            => source.ApplyProcessor(new RecursiveImageProcessor(source.GetDrawingOptions(), path, operation));
+    }
+}

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

@@ -0,0 +1,101 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors;
+
+namespace SixLabors.ImageSharp.Drawing.Processing.Processors.Drawing
+{
+    /// <summary>
+    /// Allows the recursive application of processing operations against and image.
+    /// </summary>
+    public class RecursiveImageProcessor : IImageProcessor
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RecursiveImageProcessor"/> class.
+        /// </summary>
+        /// <param name="options">The drawing options.</param>
+        /// <param name="path">The logic path.</param>
+        /// <param name="operation">The operation to perform on the source.</param>
+        public RecursiveImageProcessor(DrawingOptions options, IPath path, Action<IImageProcessingContext> operation)
+        {
+            this.Options = options;
+            this.Path = path;
+            this.Operation = operation;
+        }
+
+        /// <summary>
+        /// Gets the drawing options.
+        /// </summary>
+        public DrawingOptions Options { get; }
+
+        /// <summary>
+        /// Gets the logic path.
+        /// </summary>
+        public IPath Path { get; }
+
+        /// <summary>
+        /// Gets the operation to perform on the source.
+        /// </summary>
+        public Action<IImageProcessingContext> Operation { get; }
+
+        /// <inheritdoc/>
+        public IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>(
+            Configuration configuration,
+            Image<TPixel> source,
+            Rectangle sourceRectangle)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => new RecursiveImageProcessorInner<TPixel>(this, source, configuration, sourceRectangle);
+
+        /// <summary>
+        /// The main workhorse class. This has access to the pixel buffer but
+        /// in an abstract/generic way.
+        /// </summary>
+        /// <typeparam name="TPixel">The type of pixel.</typeparam>
+        private class RecursiveImageProcessorInner<TPixel> : IImageProcessor<TPixel>
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            private readonly RecursiveImageProcessor recursiveImageProcessor;
+            private readonly Image<TPixel> source;
+            private readonly Configuration configuration;
+            private readonly Rectangle sourceRectangle;
+
+            public RecursiveImageProcessorInner(RecursiveImageProcessor recursiveImageProcessor, Image<TPixel> source, Configuration configuration, Rectangle sourceRectangle)
+            {
+                this.recursiveImageProcessor = recursiveImageProcessor;
+                this.source = source;
+                this.configuration = configuration;
+                this.sourceRectangle = sourceRectangle;
+            }
+
+            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
+                // 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);
+
+                // 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);
+                using IImageProcessor<TPixel> p = processor.CreatePixelSpecificProcessor(this.configuration, this.source, this.sourceRectangle);
+
+                // Fill the shape using the image brush
+                p.Execute();
+            }
+        }
+    }
+}

tests/ImageSharp.Drawing.Tests/Drawing/ClipTests.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.Drawing.Processing;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Drawing
+{
+    [GroupOutput("Drawing")]
+    public class ClipTests
+    {
+        [Theory]
+        [WithBasicTestPatternImages(250, 350, PixelTypes.Rgba32)]
+        public void Clip<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => provider.RunValidatingProcessorTest(
+            x =>
+            {
+                Size size = x.GetCurrentSize();
+                int outerRadii = Math.Min(size.Width, size.Height) / 2;
+                var star = new Star(new PointF(size.Width / 2, size.Height / 2), 5, outerRadii / 2, outerRadii);
+                x.Clip(star, x => x.DetectEdges());
+            },
+            appendPixelTypeToFileName: false,
+            appendSourceFileOrDescription: false);
+    }
+}