Added channel overloads to Normalize, BilateralBlur and MotionBlur.

Author: dlemstra

src/Magick.NET.Core/IMagickImage.cs

@@ -1395,6 +1395,14 @@ public partial interface IMagickImage : IMagickImageCreateOperations, IDisposabl
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     void Normalize();
 
+    /// <summary>
+    /// Normalize the specified channel(s) of the image (increase contrast by normalizing the pixel
+    /// values to span the full range of color values).
+    /// </summary>
+    /// <param name="channels">The channel(s) that should be normalized.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    void Normalize(Channels channels);
+
     /// <summary>
     /// Perform a ordered dither based on a number of pre-defined dithering threshold maps, but over
     /// multiple intensity levels.

src/Magick.NET.Core/IMagickImageCreateOperations.cs

@@ -200,6 +200,15 @@ public interface IMagickImageCreateOperations
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     void BilateralBlur(uint width, uint height);
 
+    /// <summary>
+    /// Applies a non-linear, edge-preserving, and noise-reducing smoothing filter.
+    /// </summary>
+    /// <param name="width">The width of the neighborhood in pixels.</param>
+    /// <param name="height">The height of the neighborhood in pixels.</param>
+    /// <param name="channels">The channel(s) that should be blurred.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    void BilateralBlur(uint width, uint height, Channels channels);
+
     /// <summary>
     /// Applies a non-linear, edge-preserving, and noise-reducing smoothing filter.
     /// </summary>
@@ -210,6 +219,17 @@ public interface IMagickImageCreateOperations
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     void BilateralBlur(uint width, uint height, double intensitySigma, double spatialSigma);
 
+    /// <summary>
+    /// Applies a non-linear, edge-preserving, and noise-reducing smoothing filter.
+    /// </summary>
+    /// <param name="width">The width of the neighborhood in pixels.</param>
+    /// <param name="height">The height of the neighborhood in pixels.</param>
+    /// <param name="intensitySigma">The sigma in the intensity space.</param>
+    /// <param name="spatialSigma">The sigma in the coordinate space.</param>
+    /// <param name="channels">The channel(s) that should be blurred.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    void BilateralBlur(uint width, uint height, double intensitySigma, double spatialSigma, Channels channels);
+
     /// <summary>
     /// Simulate a scene at nighttime in the moonlight.
     /// </summary>
@@ -746,6 +766,16 @@ public interface IMagickImageCreateOperations
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     void MotionBlur(double radius, double sigma, double angle);
 
+    /// <summary>
+    /// Motion blur the specified channel(s) of the image with the specified blur factor.
+    /// </summary>
+    /// <param name="radius">The radius of the Gaussian, in pixels, not counting the center pixel.</param>
+    /// <param name="sigma">The standard deviation of the Laplacian, in pixels.</param>
+    /// <param name="angle">The angle the object appears to be comming from (zero degrees is from the right).</param>
+    /// <param name="channels">The channel(s) that should be blurred.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    void MotionBlur(double radius, double sigma, double angle, Channels channels);
+
     /// <summary>
     /// Oilpaint image (image looks like oil painting).
     /// </summary>

src/Magick.NET/MagickImage.CloneMutator.cs

@@ -115,13 +115,19 @@ public void AutoOrient()
             => SetResult(NativeMagickImage.AutoOrient());
 
         public void BilateralBlur(uint width, uint height)
+            => BilateralBlur(width, height, ImageMagick.Channels.Undefined);
+
+        public void BilateralBlur(uint width, uint height, Channels channels)
         {
             var intensitySigma = Math.Sqrt((width * width) + (height * height));
-            BilateralBlur(width, height, intensitySigma, intensitySigma * 0.25);
+            BilateralBlur(width, height, intensitySigma, intensitySigma * 0.25, channels);
         }
 
         public void BilateralBlur(uint width, uint height, double intensitySigma, double spatialSigma)
-            => SetResult(NativeMagickImage.BilateralBlur(width, height, intensitySigma, spatialSigma));
+            => BilateralBlur(width, height, intensitySigma, spatialSigma, ImageMagick.Channels.Undefined);
+
+        public void BilateralBlur(uint width, uint height, double intensitySigma, double spatialSigma, Channels channels)
+            => SetResult(NativeMagickImage.BilateralBlur(width, height, intensitySigma, spatialSigma, channels));
 
         public void BlueShift()
             => BlueShift(1.5);
@@ -420,17 +426,20 @@ public void Morphology(IMorphologySettings settings)
 
             if (settings.UserKernel is not null && settings.UserKernel.Length > 0)
             {
-                SetResult(NativeMagickImage.Morphology(settings.Method, settings.UserKernel, settings.Channels, settings.Iterations));
+                SetResult(NativeMagickImage.Morphology(settings.Method, settings.UserKernel, settings.Iterations, settings.Channels));
             }
             else
             {
                 var kernel = EnumHelper.GetName(settings.Kernel).ToLowerInvariant() + ":" + settings.KernelArguments;
-                SetResult(NativeMagickImage.Morphology(settings.Method, kernel, settings.Channels, settings.Iterations));
+                SetResult(NativeMagickImage.Morphology(settings.Method, kernel, settings.Iterations, settings.Channels));
             }
         }
 
         public void MotionBlur(double radius, double sigma, double angle)
-            => SetResult(NativeMagickImage.MotionBlur(radius, sigma, angle));
+            => MotionBlur(radius, sigma, angle, ImageMagick.Channels.Undefined);
+
+        public void MotionBlur(double radius, double sigma, double angle, Channels channels)
+            => SetResult(NativeMagickImage.MotionBlur(radius, sigma, angle, channels));
 
         public void OilPaint()
             => OilPaint(3.0, 1.0);

src/Magick.NET/MagickImage.cs

@@ -1274,6 +1274,19 @@ public void BilateralBlur(uint width, uint height)
         mutator.BilateralBlur(width, height);
     }
 
+    /// <summary>
+    /// Applies a non-linear, edge-preserving, and noise-reducing smoothing filter.
+    /// </summary>
+    /// <param name="width">The width of the neighborhood in pixels.</param>
+    /// <param name="height">The height of the neighborhood in pixels.</param>
+    /// <param name="channels">The channel(s) that should be blurred.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    public void BilateralBlur(uint width, uint height, Channels channels)
+    {
+        using var mutator = new Mutator(_nativeInstance);
+        mutator.BilateralBlur(width, height, channels);
+    }
+
     /// <summary>
     /// Applies a non-linear, edge-preserving, and noise-reducing smoothing filter.
     /// </summary>
@@ -1288,6 +1301,21 @@ public void BilateralBlur(uint width, uint height, double intensitySigma, double
         mutator.BilateralBlur(width, height, intensitySigma, spatialSigma);
     }
 
+    /// <summary>
+    /// Applies a non-linear, edge-preserving, and noise-reducing smoothing filter.
+    /// </summary>
+    /// <param name="width">The width of the neighborhood in pixels.</param>
+    /// <param name="height">The height of the neighborhood in pixels.</param>
+    /// <param name="intensitySigma">The sigma in the intensity space.</param>
+    /// <param name="spatialSigma">The sigma in the coordinate space.</param>
+    /// <param name="channels">The channel(s) that should be blurred.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    public void BilateralBlur(uint width, uint height, double intensitySigma, double spatialSigma, Channels channels)
+    {
+        using var mutator = new Mutator(_nativeInstance);
+        mutator.BilateralBlur(width, height, intensitySigma, spatialSigma, channels);
+    }
+
     /// <summary>
     /// Forces all pixels below the threshold into black while leaving all pixels at or above
     /// the threshold unchanged.
@@ -4188,6 +4216,20 @@ public void MotionBlur(double radius, double sigma, double angle)
         mutator.MotionBlur(radius, sigma, angle);
     }
 
+    /// <summary>
+    /// Motion blur the specified channel(s) of the image with the specified blur factor.
+    /// </summary>
+    /// <param name="radius">The radius of the Gaussian, in pixels, not counting the center pixel.</param>
+    /// <param name="sigma">The standard deviation of the Laplacian, in pixels.</param>
+    /// <param name="angle">The angle the object appears to be comming from (zero degrees is from the right).</param>
+    /// <param name="channels">The channel(s) that should be blurred.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    public void MotionBlur(double radius, double sigma, double angle, Channels channels)
+    {
+        using var mutator = new Mutator(_nativeInstance);
+        mutator.MotionBlur(radius, sigma, angle, channels);
+    }
+
     /// <summary>
     /// Negate colors in image.
     /// </summary>
@@ -4224,7 +4266,16 @@ public void NegateGrayscale(Channels channels)
     /// </summary>
     /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
     public void Normalize()
-        => _nativeInstance.Normalize();
+        => Normalize(ImageMagick.Channels.Undefined);
+
+    /// <summary>
+    /// Normalize the specified channel(s) of the image (increase contrast by normalizing the pixel
+    /// values to span the full range of color values).
+    /// </summary>
+    /// <param name="channels">The channel(s) that should be normalized.</param>
+    /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+    public void Normalize(Channels channels)
+        => _nativeInstance.Normalize(channels);
 
     /// <summary>
     /// Oilpaint image (image looks like oil painting).

src/Magick.NET/Native/MagickImage.cs

@@ -260,7 +260,7 @@ private unsafe sealed partial class NativeMagickImage : NativeInstance, INativeM
         public partial void AutoThreshold(AutoThresholdMethod method);
 
         [Throws]
-        public partial IntPtr BilateralBlur(nuint width, nuint height, double intensitySigma, double spatialSigma);
+        public partial IntPtr BilateralBlur(nuint width, nuint height, double intensitySigma, double spatialSigma, Channels channels);
 
         [Throws]
         public partial void BlackThreshold(string threshold, Channels channels);
@@ -537,16 +537,16 @@ private unsafe sealed partial class NativeMagickImage : NativeInstance, INativeM
         public partial IntPtr MinimumBoundingBox(out nuint length);
 
         [Throws]
-        public partial IntPtr Morphology(MorphologyMethod method, string kernel, Channels channels, nint iterations);
+        public partial IntPtr Morphology(MorphologyMethod method, string kernel, nint iterations, Channels channels);
 
         [Throws]
-        public partial IntPtr MotionBlur(double radius, double sigma, double angle);
+        public partial IntPtr MotionBlur(double radius, double sigma, double angle, Channels channels);
 
         [Throws]
         public partial void Negate(bool onlyGrayscale, Channels channels);
 
         [Throws]
-        public partial void Normalize();
+        public partial void Normalize(Channels channels);
 
         [Throws]
         public partial IntPtr OilPaint(double radius, double sigma);

tests/Magick.NET.Tests/MagickImageTests/TheBilateralBlurMethod.cs

@@ -23,5 +23,16 @@ public void ShouldApplyTheFilter()
             Assert.InRange(image.Compare(blurredImage, ErrorMetric.RootMeanSquared), 0.00084, 0.00085);
 #endif
         }
+
+        [Fact]
+        public void ShouldOnlyBlurTheSpecifiedChannels()
+        {
+            using var image = new MagickImage(Files.NoisePNG);
+            using var original = image.Clone();
+            image.BilateralBlur(2, 2, Channels.Red);
+
+            Assert.NotEqual(0, original.Compare(image, ErrorMetric.RootMeanSquared, Channels.Red));
+            Assert.Equal(0, original.Compare(image, ErrorMetric.RootMeanSquared, Channels.Green | Channels.Blue));
+        }
     }
 }

tests/Magick.NET.Tests/MagickImageTests/TheMotionBlurMethod.cs

@@ -20,5 +20,16 @@ public void ShouldMotionBlurTheImage()
 
             Assert.InRange(motionBlurred.Compare(original, ErrorMetric.RootMeanSquared), 0.11019, 0.11020);
         }
+
+        [Fact]
+        public void ShouldOnlyBlurTheSpecifiedChannels()
+        {
+            using var image = new MagickImage(Files.Builtin.Logo);
+            using var original = image.Clone();
+            image.MotionBlur(4.0, 5.4, 10.6, Channels.Red);
+
+            Assert.NotEqual(0, original.Compare(image, ErrorMetric.RootMeanSquared, Channels.Red));
+            Assert.Equal(0, original.Compare(image, ErrorMetric.RootMeanSquared, Channels.Green | Channels.Blue));
+        }
     }
 }

tests/Magick.NET.Tests/MagickImageTests/TheNormalizeMethod.cs

@@ -37,5 +37,16 @@ public void ShouldNormalizeTheImage()
             ColorAssert.Equal(new MagickColor("#00000000b3ef"), colorRange, 101, 99);
 #endif
         }
+
+        [Fact]
+        public void ShouldOnlyNormalizeTheSpecifiedChannels()
+        {
+            using var image = new MagickImage("gradient:gray70-gray30", 100, 100);
+            using var original = image.Clone();
+            image.Normalize(Channels.Red);
+
+            Assert.NotEqual(0, original.Compare(image, ErrorMetric.RootMeanSquared, Channels.Red));
+            Assert.Equal(0, original.Compare(image, ErrorMetric.RootMeanSquared, Channels.Green | Channels.Blue));
+        }
     }
 }