Wire up Rgb working spaces

Author: JimBobSquarePants

src/ImageSharp/ColorProfiles/ChromaticAdaptionWhitePointSource.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// Enumerate the possible sources of the white point used in chromatic adaptation.
+/// </summary>
+public enum ChromaticAdaptionWhitePointSource
+{
+    /// <summary>
+    /// The white point of the source color space.
+    /// </summary>
+    WhitePoint,
+
+    /// <summary>
+    /// The white point of the source working space.
+    /// </summary>
+    RgbWorkingSpace
+}

src/ImageSharp/ColorProfiles/CieLab.cs

@@ -172,4 +172,7 @@ public static void ToProfileConnectionSpace(ColorConversionOptions options, Read
             destination[i] = lab.ToProfileConnectingSpace(options);
         }
     }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource() => ChromaticAdaptionWhitePointSource.WhitePoint;
 }

src/ImageSharp/ColorProfiles/CieLch.cs

@@ -163,4 +163,7 @@ public static void ToProfileConnectionSpace(ColorConversionOptions options, Read
             destination[i] = lch.ToProfileConnectingSpace(options);
         }
     }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource() => ChromaticAdaptionWhitePointSource.WhitePoint;
 }

src/ImageSharp/ColorProfiles/CieXyChromaticityCoordinates.cs

@@ -0,0 +1,83 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.CompilerServices;
+
+// ReSharper disable CompareOfFloatsByEqualityOperator
+namespace SixLabors.ImageSharp.ColorProfiles;
+
+/// <summary>
+/// Represents the coordinates of CIEXY chromaticity space.
+/// </summary>
+public readonly struct CieXyChromaticityCoordinates : IEquatable<CieXyChromaticityCoordinates>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CieXyChromaticityCoordinates"/> struct.
+    /// </summary>
+    /// <param name="x">Chromaticity coordinate x (usually from 0 to 1)</param>
+    /// <param name="y">Chromaticity coordinate y (usually from 0 to 1)</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public CieXyChromaticityCoordinates(float x, float y)
+    {
+        this.X = x;
+        this.Y = y;
+    }
+
+    /// <summary>
+    /// Gets the chromaticity X-coordinate.
+    /// </summary>
+    /// <remarks>
+    /// Ranges usually from 0 to 1.
+    /// </remarks>
+    public readonly float X { get; }
+
+    /// <summary>
+    /// Gets the chromaticity Y-coordinate
+    /// </summary>
+    /// <remarks>
+    /// Ranges usually from 0 to 1.
+    /// </remarks>
+    public readonly float Y { get; }
+
+    /// <summary>
+    /// Compares two <see cref="CieXyChromaticityCoordinates"/> objects for equality.
+    /// </summary>
+    /// <param name="left">The <see cref="CieXyChromaticityCoordinates"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="CieXyChromaticityCoordinates"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static bool operator ==(CieXyChromaticityCoordinates left, CieXyChromaticityCoordinates right)
+        => left.Equals(right);
+
+    /// <summary>
+    /// Compares two <see cref="CieXyChromaticityCoordinates"/> objects for inequality
+    /// </summary>
+    /// <param name="left">The <see cref="CieXyChromaticityCoordinates"/> on the left side of the operand.</param>
+    /// <param name="right">The <see cref="CieXyChromaticityCoordinates"/> on the right side of the operand.</param>
+    /// <returns>
+    /// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
+    /// </returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static bool operator !=(CieXyChromaticityCoordinates left, CieXyChromaticityCoordinates right)
+        => !left.Equals(right);
+
+    /// <inheritdoc />
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public override int GetHashCode()
+        => HashCode.Combine(this.X, this.Y);
+
+    /// <inheritdoc/>
+    public override string ToString()
+        => FormattableString.Invariant($"CieXyChromaticityCoordinates({this.X:#0.##}, {this.Y:#0.##})");
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+        => obj is CieXyChromaticityCoordinates other && this.Equals(other);
+
+    /// <inheritdoc/>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public bool Equals(CieXyChromaticityCoordinates other)
+        => this.X.Equals(other.X) && this.Y.Equals(other.Y);
+}

src/ImageSharp/ColorProfiles/CieXyz.cs

@@ -121,4 +121,7 @@ public static void ToProfileConnectionSpace(ColorConversionOptions options, Read
         Guard.DestinationShouldNotBeTooShort(source, destination, nameof(destination));
         source.CopyTo(destination[..source.Length]);
     }
+
+    /// <inheritdoc/>
+    public static ChromaticAdaptionWhitePointSource GetChromaticAdaptionWhitePointSource() => ChromaticAdaptionWhitePointSource.WhitePoint;
 }

src/ImageSharp/ColorProfiles/ColorConversionOptions.cs

@@ -2,6 +2,8 @@
 // Licensed under the Six Labors Split License.
 
 using System.Numerics;
+using SixLabors.ColorProfiles;
+using SixLabors.ImageSharp.ColorProfiles.WorkingSpaces;
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.ColorProfiles;
@@ -33,6 +35,16 @@ public class ColorConversionOptions
     /// </summary>
     public CieXyz TargetWhitePoint { get; init; } = Illuminants.D50;
 
+    /// <summary>
+    /// Gets the source working space used for companding in conversions from/to XYZ color space.
+    /// </summary>
+    public RgbWorkingSpace RgbWorkingSpace { get; init; } = RgbWorkingSpaces.SRgb;
+
+    /// <summary>
+    /// Gets the destination working space used for companding in conversions from/to XYZ color space.
+    /// </summary>
+    public RgbWorkingSpace TargetRgbWorkingSpace { get; init; } = RgbWorkingSpaces.SRgb;
+
     /// <summary>
     /// Gets the transformation matrix used in conversion to perform chromatic adaptation.
     /// </summary>

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieLabCieXyz.cs

@@ -21,7 +21,7 @@ public static TTo Convert<TFrom, TTo>(this ColorProfileConverter converter, TFro
         CieXyz pcsTo = pcsFrom.ToProfileConnectingSpace(options);
 
         // Adapt to target white point
-        VonKriesChromaticAdaptation.Transform(options, in pcsTo);
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, in pcsTo);
 
         // Convert to output from PCS
         return TTo.FromProfileConnectingSpace(options, pcsTo);
@@ -44,7 +44,7 @@ public static void Convert<TFrom, TTo>(this ColorProfileConverter converter, Rea
         CieLab.ToProfileConnectionSpace(options, pcsFrom, pcsTo);
 
         // Adapt to target white point
-        VonKriesChromaticAdaptation.Transform(options, pcsTo, pcsTo);
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, pcsTo, pcsTo);
 
         // Convert to output from PCS
         TTo.FromProfileConnectionSpace(options, pcsTo, destination);

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieLab.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
@@ -18,7 +18,7 @@ public static TTo Convert<TFrom, TTo>(this ColorProfileConverter converter, TFro
         CieXyz pcsFrom = source.ToProfileConnectingSpace(options);
 
         // Adapt to target white point
-        VonKriesChromaticAdaptation.Transform(options, in pcsFrom);
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, in pcsFrom);
 
         // Convert between PCS
         CieLab pcsTo = CieLab.FromProfileConnectingSpace(options, in pcsFrom);
@@ -39,7 +39,7 @@ public static void Convert<TFrom, TTo>(this ColorProfileConverter converter, Rea
         TFrom.ToProfileConnectionSpace(options, source, pcsFrom);
 
         // Adapt to target white point
-        VonKriesChromaticAdaptation.Transform(options, pcsFrom, pcsFrom);
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, pcsFrom, pcsFrom);
 
         // Convert between PCS.
         using IMemoryOwner<CieLab> pcsToOwner = options.MemoryAllocator.Allocate<CieLab>(source.Length);

src/ImageSharp/ColorProfiles/ColorProfileConverterExtensionsCieXyzCieXyz.cs

@@ -18,7 +18,7 @@ public static TTo Convert<TFrom, TTo>(this ColorProfileConverter converter, TFro
         CieXyz pcsFrom = source.ToProfileConnectingSpace(options);
 
         // Adapt to target white point
-        VonKriesChromaticAdaptation.Transform(options, in pcsFrom);
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, in pcsFrom);
 
         // Convert between PCS
         CieXyz pcsTo = CieXyz.FromProfileConnectingSpace(options, in pcsFrom);
@@ -39,7 +39,7 @@ public static void Convert<TFrom, TTo>(this ColorProfileConverter converter, Rea
         TFrom.ToProfileConnectionSpace(options, source, pcsFrom);
 
         // Adapt to target white point
-        VonKriesChromaticAdaptation.Transform(options, pcsFrom, pcsFrom);
+        VonKriesChromaticAdaptation.Transform<TFrom, TTo>(options, pcsFrom, pcsFrom);
 
         // Convert between PCS.
         using IMemoryOwner<CieXyz> pcsToOwner = options.MemoryAllocator.Allocate<CieXyz>(source.Length);

src/ImageSharp/ColorProfiles/Companding/CompandingUtilities.cs

@@ -0,0 +1,171 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Collections.Concurrent;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.ColorProfiles.Companding;
+
+/// <summary>
+/// Companding utilities that allow the accelerated compression-expansion of color channels.
+/// </summary>
+public static class CompandingUtilities
+{
+    private const int Length = Scale + 2; // 256kb @ 16bit precision.
+    private const int Scale = (1 << 16) - 1;
+    private static readonly ConcurrentDictionary<(Type, double), Lazy<float[]>> LookupTables = new();
+
+    /// <summary>
+    /// Lazily creates and stores a companding lookup table using the given function and modifier.
+    /// </summary>
+    /// <typeparam name="T">The type of companding function.</typeparam>
+    /// <param name="compandingFunction">The companding function.</param>
+    /// <param name="modifier">A modifier to pass to the function.</param>
+    /// <returns>The <see cref="float"/> array.</returns>
+    public static Lazy<float[]> GetLookupTable<T>(Func<double, double, double> compandingFunction, double modifier = 0)
+        => LookupTables.GetOrAdd((typeof(T), modifier), args => new(() => CreateLookupTableImpl(compandingFunction, args.Item2), true));
+
+    /// <summary>
+    /// Creates a companding lookup table using the given function.
+    /// </summary>
+    /// <param name="compandingFunction">The companding function.</param>
+    /// <param name="modifier">A modifier to pass to the function.</param>
+    /// <returns>The <see cref="float"/> array.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static float[] CreateLookupTableImpl(Func<double, double, double> compandingFunction, double modifier = 0)
+    {
+        float[] result = new float[Length];
+
+        for (int i = 0; i < result.Length; i++)
+        {
+            double d = (double)i / Scale;
+            d = compandingFunction(d, modifier);
+            result[i] = (float)d;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Performs the companding operation on the given vectors using the given table.
+    /// </summary>
+    /// <param name="vectors">The span of vectors.</param>
+    /// <param name="table">The lookup table.</param>
+    public static void Compand(Span<Vector4> vectors, float[] table)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(table.Length, Length, nameof(table));
+
+        if (Avx2.IsSupported && vectors.Length >= 2)
+        {
+            CompandAvx2(vectors, table);
+
+            if (Numerics.Modulo2(vectors.Length) != 0)
+            {
+                // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
+                ref Vector4 last = ref MemoryMarshal.GetReference(vectors[^1..]);
+                last = Compand(last, table);
+            }
+        }
+        else
+        {
+            CompandScalar(vectors, table);
+        }
+    }
+
+    /// <summary>
+    /// Performs the companding operation on the given vector using the given table.
+    /// </summary>
+    /// <param name="vector">The vector.</param>
+    /// <param name="table">The lookup table.</param>
+    /// <returns>The <see cref="Vector4"/></returns>
+    public static Vector4 Compand(Vector4 vector, float[] table)
+    {
+        DebugGuard.MustBeGreaterThanOrEqualTo(table.Length, Length, nameof(table));
+
+        Vector4 zero = Vector4.Zero;
+        Vector4 scale = new(Scale);
+
+        Vector4 multiplied = Numerics.Clamp(vector * Scale, zero, scale);
+
+        float f0 = multiplied.X;
+        float f1 = multiplied.Y;
+        float f2 = multiplied.Z;
+
+        uint i0 = (uint)f0;
+        uint i1 = (uint)f1;
+        uint i2 = (uint)f2;
+
+        // Alpha is already a linear representation of opacity so we do not want to convert it.
+        vector.X = Numerics.Lerp(table[i0], table[i0 + 1], f0 - (int)i0);
+        vector.Y = Numerics.Lerp(table[i1], table[i1 + 1], f1 - (int)i1);
+        vector.Z = Numerics.Lerp(table[i2], table[i2 + 1], f2 - (int)i2);
+
+        return vector;
+    }
+
+    private static unsafe void CompandAvx2(Span<Vector4> vectors, float[] table)
+    {
+        fixed (float* tablePointer = &MemoryMarshal.GetArrayDataReference(table))
+        {
+            Vector256<float> scale = Vector256.Create((float)Scale);
+            Vector256<float> zero = Vector256<float>.Zero;
+            Vector256<int> offset = Vector256.Create(1);
+
+            // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
+            ref Vector256<float> vectorsBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(vectors));
+            ref Vector256<float> vectorsLast = ref Unsafe.Add(ref vectorsBase, (uint)vectors.Length / 2u);
+
+            while (Unsafe.IsAddressLessThan(ref vectorsBase, ref vectorsLast))
+            {
+                Vector256<float> multiplied = Avx.Multiply(scale, vectorsBase);
+                multiplied = Avx.Min(Avx.Max(zero, multiplied), scale);
+
+                Vector256<int> truncated = Avx.ConvertToVector256Int32WithTruncation(multiplied);
+                Vector256<float> truncatedF = Avx.ConvertToVector256Single(truncated);
+
+                Vector256<float> low = Avx2.GatherVector256(tablePointer, truncated, sizeof(float));
+                Vector256<float> high = Avx2.GatherVector256(tablePointer, Avx2.Add(truncated, offset), sizeof(float));
+
+                // Alpha is already a linear representation of opacity so we do not want to convert it.
+                Vector256<float> companded = Numerics.Lerp(low, high, Avx.Subtract(multiplied, truncatedF));
+                vectorsBase = Avx.Blend(companded, vectorsBase, Numerics.BlendAlphaControl);
+                vectorsBase = ref Unsafe.Add(ref vectorsBase, 1);
+            }
+        }
+    }
+
+    private static unsafe void CompandScalar(Span<Vector4> vectors, float[] table)
+    {
+        fixed (float* tablePointer = &MemoryMarshal.GetArrayDataReference(table))
+        {
+            Vector4 zero = Vector4.Zero;
+            Vector4 scale = new(Scale);
+            ref Vector4 vectorsBase = ref MemoryMarshal.GetReference(vectors);
+            ref Vector4 vectorsLast = ref Unsafe.Add(ref vectorsBase, (uint)vectors.Length);
+
+            while (Unsafe.IsAddressLessThan(ref vectorsBase, ref vectorsLast))
+            {
+                Vector4 multiplied = Numerics.Clamp(vectorsBase * Scale, zero, scale);
+
+                float f0 = multiplied.X;
+                float f1 = multiplied.Y;
+                float f2 = multiplied.Z;
+
+                uint i0 = (uint)f0;
+                uint i1 = (uint)f1;
+                uint i2 = (uint)f2;
+
+                // Alpha is already a linear representation of opacity so we do not want to convert it.
+                vectorsBase.X = Numerics.Lerp(tablePointer[i0], tablePointer[i0 + 1], f0 - (int)i0);
+                vectorsBase.Y = Numerics.Lerp(tablePointer[i1], tablePointer[i1 + 1], f1 - (int)i1);
+                vectorsBase.Z = Numerics.Lerp(tablePointer[i2], tablePointer[i2 + 1], f2 - (int)i2);
+
+                vectorsBase = ref Unsafe.Add(ref vectorsBase, 1);
+            }
+        }
+    }
+}