Added ScaleToDouble to the quantum scalers.

Author: dlemstra

src/Magick.NET.Core/Scaler/ByteQuantumScaler.cs

@@ -18,4 +18,8 @@ public byte ScaleFromUnsignedShort(ushort value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public byte ScaleToByte(byte value)
         => value;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public double ScaleToDouble(byte value)
+        => value / 255.0;
 }

src/Magick.NET.Core/Scaler/FloatQuantumScaler.cs

@@ -27,4 +27,8 @@ public byte ScaleToByte(float value)
 
         return (byte)(scaledValue + 0.5f);
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public double ScaleToDouble(float value)
+        => value / 65535.0;
 }

src/Magick.NET.Core/Scaler/IQuantumScaler{TQuantumType}.cs

@@ -32,4 +32,11 @@ public interface IQuantumScaler<TQuantumType>
     /// <param name="value">The value to scale.</param>
     /// <returns>The value scaled to a byte.</returns>
     byte ScaleToByte(TQuantumType value);
+
+    /// <summary>
+    /// Scales the specified value to a double (range is 0.0 to 1.0).
+    /// </summary>
+    /// <param name="value">The value to scale.</param>
+    /// <returns>The value scaled to a double.</returns>
+    double ScaleToDouble(TQuantumType value);
 }

src/Magick.NET.Core/Scaler/UnsignedShortQuantumScaler.cs

@@ -18,4 +18,8 @@ public ushort ScaleFromUnsignedShort(ushort value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public byte ScaleToByte(ushort value)
         => (byte)((value + 128U - ((value + 128U) >> 8)) >> 8);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public double ScaleToDouble(ushort value)
+        => value / 65535.0;
 }

src/Magick.NET/Colors/ColorGray.cs

@@ -35,10 +35,11 @@ public ColorGray(double shade)
     private ColorGray(IMagickColor<QuantumType> color)
       : base(color)
     {
+        var quantum = QuantumScalerFactory.Create<QuantumType>();
         _shade =
-            (0.212656 * Quantum.ScaleToDouble(color.R)) +
-            (0.715158 * Quantum.ScaleToDouble(color.G)) +
-            (0.072186 * Quantum.ScaleToDouble(color.B));
+            (0.212656 * quantum.ScaleToDouble(color.R)) +
+            (0.715158 * quantum.ScaleToDouble(color.G)) +
+            (0.072186 * quantum.ScaleToDouble(color.B));
     }
 
     /// <summary>

src/Magick.NET/MagickImage.CloneMutator.cs

@@ -611,18 +611,19 @@ public void SparseColor(Channels channels, SparseColorMethod method, IEnumerable
 
             var arguments = new List<double>();
 
+            var quantum = QuantumScalerFactory.Create<QuantumType>();
             foreach (var arg in args)
             {
                 arguments.Add(arg.X);
                 arguments.Add(arg.Y);
                 if (hasRed)
-                    arguments.Add(Quantum.ScaleToDouble(arg.Color.R));
+                    arguments.Add(quantum.ScaleToDouble(arg.Color.R));
                 if (hasGreen)
-                    arguments.Add(Quantum.ScaleToDouble(arg.Color.G));
+                    arguments.Add(quantum.ScaleToDouble(arg.Color.G));
                 if (hasBlue)
-                    arguments.Add(Quantum.ScaleToDouble(arg.Color.B));
+                    arguments.Add(quantum.ScaleToDouble(arg.Color.B));
                 if (hasAlpha)
-                    arguments.Add(Quantum.ScaleToDouble(arg.Color.A));
+                    arguments.Add(quantum.ScaleToDouble(arg.Color.A));
             }
 
             Throw.IfTrue(arguments.Count == 0, nameof(args), "Value cannot be empty");

src/Magick.NET/Quantum.cs

@@ -70,7 +70,4 @@ internal static QuantumType ConvertFromInteger(int value)
 
     internal static QuantumType ScaleToQuantum(double value)
         => (QuantumType)Math.Min(Math.Max(0, value * Max), Max);
-
-    internal static double ScaleToDouble(QuantumType value)
-        => (1.0 / Max) * value;
 }

tests/Magick.NET.Core.Tests/Scaler/ByteQuantumScaler/TheScaleToDoubleMethod.cs

@@ -0,0 +1,24 @@
+// Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
+// Licensed under the Apache License, Version 2.0.
+
+using ImageMagick;
+using Xunit;
+
+namespace Magick.NET.Core.Tests;
+
+public partial class ByteQuantumScalerTests
+{
+    public class TheScaleToDoubleMethod
+    {
+        [Theory]
+        [InlineData(byte.MinValue, 0.0)]
+        [InlineData(byte.MaxValue, 1.0)]
+        public void ShouldScaleByteToDouble(byte input, double output)
+        {
+            var scaler = new ByteQuantumScaler();
+            var result = scaler.ScaleToDouble(input);
+
+            Assert.Equal(output, result);
+        }
+    }
+}

tests/Magick.NET.Core.Tests/Scaler/FloatQuantumScaler/TheScaleToDoubleMethod.cs

@@ -0,0 +1,24 @@
+// Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
+// Licensed under the Apache License, Version 2.0.
+
+using ImageMagick;
+using Xunit;
+
+namespace Magick.NET.Core.Tests;
+
+public partial class FloatQuantumScalerTests
+{
+    public class TheScaleToDoubleMethod
+    {
+        [Theory]
+        [InlineData(ushort.MinValue, 0.0)]
+        [InlineData(ushort.MaxValue, 1.0)]
+        public void ShouldScaleFloatToDouble(float input, double output)
+        {
+            var scaler = new FloatQuantumScaler();
+            var result = scaler.ScaleToDouble(input);
+
+            Assert.Equal(output, result);
+        }
+    }
+}

tests/Magick.NET.Core.Tests/Scaler/UnsignedShortQuantumScaler/TheScaleToDoubleMethod.cs

@@ -0,0 +1,24 @@
+// Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
+// Licensed under the Apache License, Version 2.0.
+
+using ImageMagick;
+using Xunit;
+
+namespace Magick.NET.Core.Tests;
+
+public partial class UnsignedShortQuantumScalerTests
+{
+    public class TheScaleToDoubleMethod
+    {
+        [Theory]
+        [InlineData(ushort.MinValue, 0.0)]
+        [InlineData(ushort.MaxValue, 1.0)]
+        public void ShouldScaleUnsignedShortToDouble(ushort input, double output)
+        {
+            var scaler = new UnsignedShortQuantumScaler();
+            var result = scaler.ScaleToDouble(input);
+
+            Assert.Equal(output, result);
+        }
+    }
+}